home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / gnu / bash / bash_108 / bash-108.zoo / src / y.tab.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-09-12  |  99.8 KB  |  3,597 lines
  1.  
  2. /*  A Bison parser, made from parse.y  */
  3.  
  4. #define    IF    258
  5. #define    THEN    259
  6. #define    ELSE    260
  7. #define    ELIF    261
  8. #define    FI    262
  9. #define    CASE    263
  10. #define    ESAC    264
  11. #define    FOR    265
  12. #define    WHILE    266
  13. #define    UNTIL    267
  14. #define    DO    268
  15. #define    DONE    269
  16. #define    FUNCTION    270
  17. #define    IN    271
  18. #define    BANG    272
  19. #define    WORD    273
  20. #define    NUMBER    274
  21. #define    AND_AND    275
  22. #define    OR_OR    276
  23. #define    GREATER_GREATER    277
  24. #define    LESS_LESS    278
  25. #define    LESS_AND    279
  26. #define    GREATER_AND    280
  27. #define    SEMI_SEMI    281
  28. #define    LESS_LESS_MINUS    282
  29. #define    AND_GREATER    283
  30. #define    LESS_GREATER    284
  31. #define    GREATER_BAR    285
  32. #define    yacc_EOF    286
  33.  
  34. #line 21 "parse.y"
  35.  
  36. #include <stdio.h>
  37. #include <signal.h>
  38. #include "shell.h"
  39. #include "flags.h"
  40.  
  41. #if defined (READLINE)
  42. #include <readline/readline.h>
  43. #endif /* READLINE */
  44.  
  45. #include <readline/history.h>
  46.  
  47. #define YYDEBUG 1
  48. extern int eof_encountered;
  49. extern int no_line_editing;
  50. extern int interactive, interactive_shell;
  51.  
  52. /* **************************************************************** */
  53. /*                                    */
  54. /*            "Forward" declarations                */
  55. /*                                    */
  56. /* **************************************************************** */
  57.  
  58.  
  59. /* This is kind of sickening.  In order to let these variables be seen by
  60.    all the functions that need them, I am forced to place their declarations
  61.    far away from the place where they should logically be found. */
  62.  
  63. /* prompt_string_pointer points to one of these, never to an actual string. */
  64. char *ps1_prompt, *ps2_prompt;
  65.  
  66. /* Handle on the current prompt string.     Indirectly points through
  67.    ps1_ or ps2_prompt. */
  68. char **prompt_string_pointer = (char **)NULL;
  69. char *current_prompt_string;
  70.  
  71. /* Variables to manage the task of reading here documents, because we need to
  72.    defer the reading until after a complete command has been collected. */
  73. REDIRECT *redirection_needing_here_doc = (REDIRECT *)NULL;
  74. int need_here_doc = 0;
  75.  
  76. #line 63 "parse.y"
  77. typedef union {
  78.   WORD_DESC *word;        /* the word that we read. */
  79.   int number;            /* the number that we read. */
  80.   WORD_LIST *word_list;
  81.   COMMAND *command;
  82.   REDIRECT *redirect;
  83.   ELEMENT element;
  84.   PATTERN_LIST *pattern;
  85. } YYSTYPE;
  86.  
  87. #ifndef YYLTYPE
  88. typedef
  89.   struct yyltype
  90.     {
  91.       int timestamp;
  92.       int first_line;
  93.       int first_column;
  94.       int last_line;
  95.       int last_column;
  96.       char *text;
  97.    }
  98.   yyltype;
  99.  
  100. #define YYLTYPE yyltype
  101. #endif
  102.  
  103. #include <stdio.h>
  104.  
  105. #ifndef __STDC__
  106. #define const
  107. #endif
  108.  
  109.  
  110.  
  111. #define    YYFINAL        212
  112. #define    YYFLAG        -32768
  113. #define    YYNTBASE    43
  114.  
  115. #define YYTRANSLATE(x) ((unsigned)(x) <= 286 ? yytranslate[x] : 66)
  116.  
  117. static const char yytranslate[] = {     0,
  118.      2,     2,     2,     2,     2,     2,     2,     2,     2,    33,
  119.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  120.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  121.      2,     2,     2,     2,     2,     2,     2,    31,     2,    41,
  122.     42,     2,     2,     2,    38,     2,     2,     2,     2,     2,
  123.      2,     2,     2,     2,     2,     2,     2,     2,    32,    37,
  124.      2,    36,     2,     2,     2,     2,     2,     2,     2,     2,
  125.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  126.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  127.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  128.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  129.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  130.      2,     2,    39,    35,    40,     2,     2,     2,     2,     2,
  131.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  132.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  133.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  134.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  135.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  136.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  137.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  138.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  139.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  140.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  141.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  142.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  143.      2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
  144.      6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
  145.     16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
  146.     26,    27,    28,    29,    30,    34
  147. };
  148.  
  149. static const short yyprhs[] = {     0,
  150.      0,     3,     5,     8,    10,    11,    14,    17,    20,    24,
  151.     28,    31,    35,    38,    42,    45,    49,    52,    56,    59,
  152.     63,    66,    70,    73,    77,    80,    83,    87,    90,    93,
  153.     97,    99,   101,   103,   106,   108,   111,   113,   115,   118,
  154.    125,   132,   140,   148,   159,   170,   177,   185,   192,   198,
  155.    206,   213,   219,   225,   229,   231,   237,   244,   249,   253,
  156.    258,   265,   271,   273,   276,   281,   286,   288,   291,   297,
  157.    303,   305,   309,   312,   314,   318,   322,   326,   331,   336,
  158.    341,   346,   351,   353,   356,   358,   360,   362,   363,   366,
  159.    368,   371,   374,   379,   384,   388,   392,   394,   397,   402
  160. };
  161.  
  162. static const short yyrhs[] = {    63,
  163.     33,     0,    33,     0,     1,    33,     0,    34,     0,     0,
  164.     44,    18,     0,    36,    18,     0,    37,    18,     0,    19,
  165.     36,    18,     0,    19,    37,    18,     0,    22,    18,     0,
  166.     19,    22,    18,     0,    23,    18,     0,    19,    23,    18,
  167.      0,    24,    19,     0,    19,    24,    19,     0,    25,    19,
  168.      0,    19,    25,    19,     0,    27,    18,     0,    19,    27,
  169.     18,     0,    25,    38,     0,    19,    25,    38,     0,    24,
  170.     38,     0,    19,    24,    38,     0,    28,    18,     0,    25,
  171.     18,     0,    19,    29,    18,     0,    29,    18,     0,    30,
  172.     18,     0,    19,    30,    18,     0,    18,     0,    45,     0,
  173.     45,     0,    47,    45,     0,    46,     0,    48,    46,     0,
  174.     48,     0,    50,     0,    50,    47,     0,    10,    18,    62,
  175.     13,    58,    14,     0,    10,    18,    62,    39,    58,    40,
  176.      0,    10,    18,    32,    62,    13,    58,    14,     0,    10,
  177.     18,    32,    62,    39,    58,    40,     0,    10,    18,    62,
  178.     16,    44,    61,    62,    13,    58,    14,     0,    10,    18,
  179.     62,    16,    44,    61,    62,    39,    58,    40,     0,     8,
  180.     18,    62,    16,    62,     9,     0,     8,    18,    62,    16,
  181.     55,    62,     9,     0,     8,    18,    62,    16,    53,     9,
  182.      0,     3,    58,     4,    58,     7,     0,     3,    58,     4,
  183.     58,     5,    58,     7,     0,     3,    58,     4,    58,    52,
  184.      7,     0,    11,    58,    13,    58,    14,     0,    12,    58,
  185.     13,    58,    14,     0,    41,    58,    42,     0,    51,     0,
  186.     18,    41,    42,    62,    51,     0,    15,    18,    41,    42,
  187.     62,    51,     0,    15,    18,    62,    51,     0,    39,    58,
  188.     40,     0,     6,    58,     4,    58,     0,     6,    58,     4,
  189.     58,     5,    58,     0,     6,    58,     4,    58,    52,     0,
  190.     54,     0,    55,    54,     0,    62,    57,    42,    58,     0,
  191.     62,    57,    42,    62,     0,    56,     0,    55,    56,     0,
  192.     62,    57,    42,    58,    26,     0,    62,    57,    42,    62,
  193.     26,     0,    18,     0,    57,    35,    18,     0,    62,    59,
  194.      0,    60,     0,    60,    33,    62,     0,    60,    31,    62,
  195.      0,    60,    32,    62,     0,    60,    20,    62,    60,     0,
  196.     60,    21,    62,    60,     0,    60,    31,    62,    60,     0,
  197.     60,    32,    62,    60,     0,    60,    33,    62,    60,     0,
  198.     65,     0,    17,    65,     0,    33,     0,    32,     0,    34,
  199.      0,     0,    62,    33,     0,    64,     0,    64,    31,     0,
  200.     64,    32,     0,    64,    20,    62,    64,     0,    64,    21,
  201.     62,    64,     0,    64,    31,    64,     0,    64,    32,    64,
  202.      0,    65,     0,    17,    65,     0,    65,    35,    62,    65,
  203.      0,    49,     0
  204. };
  205.  
  206. #if YYDEBUG != 0
  207. static const short yyrline[] = { 0,
  208.    102,   111,   118,   134,   144,   146,   150,   152,   154,   156,
  209.    158,   160,   162,   168,   174,   176,   178,   180,   182,   188,
  210.    194,   196,   198,   200,   202,   204,   206,   208,   218,   220,
  211.    224,   226,   230,   234,   245,   247,   251,   254,   257,   264,
  212.    266,   268,   270,   273,   275,   278,   280,   282,   287,   289,
  213.    291,   294,   296,   299,   302,   305,   308,   311,   315,   319,
  214.    321,   323,   328,   329,   333,   335,   339,   341,   345,   347,
  215.    351,   353,   362,   371,   372,   373,   375,   379,   381,   383,
  216.    385,   387,   389,   391,   398,   399,   400,   403,   404,   413,
  217.    420,   427,   436,   438,   440,   442,   444,   446,   453,   456
  218. };
  219.  
  220. static const char * const yytname[] = {   "$",
  221. "error","$illegal.","IF","THEN","ELSE","ELIF","FI","CASE","ESAC","FOR",
  222. "WHILE","UNTIL","DO","DONE","FUNCTION","IN","BANG","WORD","NUMBER","AND_AND",
  223. "OR_OR","GREATER_GREATER","LESS_LESS","LESS_AND","GREATER_AND","SEMI_SEMI","LESS_LESS_MINUS","AND_GREATER","LESS_GREATER","GREATER_BAR",
  224. "'&'","';'","'\\n'","yacc_EOF","'|'","'>'","'<'","'-'","'{'","'}'",
  225. "'('","')'","inputunit","words","redirection","simple_command_element","redirections","simple_command","command","shell_command",
  226. "group_command","elif_clause","case_clause_1","pattern_list_1","case_clause_sequence","pattern_list","pattern","list","list0","list1",
  227. "list_terminator","newlines","simple_list","simple_list1","pipeline",""
  228. };
  229. #endif
  230.  
  231. static const short yyr1[] = {     0,
  232.     43,    43,    43,    43,    44,    44,    45,    45,    45,    45,
  233.     45,    45,    45,    45,    45,    45,    45,    45,    45,    45,
  234.     45,    45,    45,    45,    45,    45,    45,    45,    45,    45,
  235.     46,    46,    47,    47,    48,    48,    49,    49,    49,    50,
  236.     50,    50,    50,    50,    50,    50,    50,    50,    50,    50,
  237.     50,    50,    50,    50,    50,    50,    50,    50,    51,    52,
  238.     52,    52,    53,    53,    54,    54,    55,    55,    56,    56,
  239.     57,    57,    58,    59,    59,    59,    59,    60,    60,    60,
  240.     60,    60,    60,    60,    61,    61,    61,    62,    62,    63,
  241.     63,    63,    64,    64,    64,    64,    64,    64,    65,    65
  242. };
  243.  
  244. static const short yyr2[] = {     0,
  245.      2,     1,     2,     1,     0,     2,     2,     2,     3,     3,
  246.      2,     3,     2,     3,     2,     3,     2,     3,     2,     3,
  247.      2,     3,     2,     3,     2,     2,     3,     2,     2,     3,
  248.      1,     1,     1,     2,     1,     2,     1,     1,     2,     6,
  249.      6,     7,     7,    10,    10,     6,     7,     6,     5,     7,
  250.      6,     5,     5,     3,     1,     5,     6,     4,     3,     4,
  251.      6,     5,     1,     2,     4,     4,     1,     2,     5,     5,
  252.      1,     3,     2,     1,     3,     3,     3,     4,     4,     4,
  253.      4,     4,     1,     2,     1,     1,     1,     0,     2,     1,
  254.      2,     2,     4,     4,     3,     3,     1,     2,     4,     1
  255. };
  256.  
  257. static const short yydefact[] = {     0,
  258.      0,    88,     0,     0,    88,    88,     0,     0,    31,     0,
  259.      0,     0,     0,     0,     0,     0,     0,     0,     2,     4,
  260.      0,     0,    88,    88,    32,    35,    37,   100,    38,    55,
  261.      0,    90,    97,     3,     0,     0,    88,    88,     0,     0,
  262.     88,    98,     0,     0,     0,     0,     0,     0,     0,     0,
  263.      0,     0,    11,    13,    15,    23,    26,    17,    21,    19,
  264.     25,    28,    29,     7,     8,     0,     0,    31,    36,    33,
  265.     39,     1,    88,    88,    91,    92,    88,    88,     0,    89,
  266.     73,    74,    83,     0,    88,     0,    88,    88,     0,     0,
  267.     88,    12,    14,    16,    24,    18,    22,    20,    27,    30,
  268.      9,    10,    59,    54,    34,     0,     0,    95,    96,     0,
  269.      0,    84,    88,    88,    88,    88,    88,    88,     0,    88,
  270.      5,    88,     0,     0,    88,    58,     0,    93,    94,     0,
  271.      0,    99,    88,    88,    49,     0,     0,     0,    76,    77,
  272.     75,     0,    63,    88,    67,     0,    88,    88,     0,     0,
  273.      0,    52,    53,     0,    56,     0,     0,    51,    78,    79,
  274.     80,    81,    82,    48,    64,    68,     0,    46,    71,     0,
  275.      0,     0,    40,     6,    86,    85,    87,    88,    41,    57,
  276.     50,    88,    88,    88,    88,    47,     0,    88,    42,    43,
  277.      0,    60,     0,     0,     0,    72,    65,    66,    88,    88,
  278.     88,    62,    69,    70,     0,     0,    61,    44,    45,     0,
  279.      0,     0
  280. };
  281.  
  282. static const short yydefgoto[] = {   210,
  283.    150,    25,    26,    71,    27,    28,    29,    30,   136,   142,
  284.    143,   144,   145,   170,    35,    81,    82,   178,    36,    31,
  285.    108,    83
  286. };
  287.  
  288. static const short yypact[] = {   151,
  289.     -8,-32768,     9,    18,-32768,-32768,    24,   350,     7,   390,
  290.     41,    46,    20,    33,    48,    54,    66,    80,-32768,-32768,
  291.     85,    92,-32768,-32768,-32768,-32768,   374,-32768,    77,-32768,
  292.     21,   104,    76,-32768,   108,   222,-32768,    86,   114,   121,
  293.     96,    76,    79,   120,   122,    36,    37,   123,   126,   127,
  294.    130,   131,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
  295. -32768,-32768,-32768,-32768,-32768,   111,    97,-32768,-32768,-32768,
  296.     77,-32768,-32768,-32768,   286,   286,-32768,-32768,   350,-32768,
  297. -32768,    99,    76,    -2,-32768,    -1,-32768,-32768,   116,   -11,
  298. -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
  299. -32768,-32768,-32768,-32768,-32768,   254,   254,    13,    13,   318,
  300.     63,    76,-32768,-32768,-32768,-32768,-32768,-32768,     4,-32768,
  301. -32768,-32768,   139,   150,-32768,-32768,   -11,-32768,-32768,   286,
  302.    286,-32768,-32768,-32768,-32768,   158,   222,   222,   222,   222,
  303.    222,   162,-32768,-32768,-32768,    11,-32768,-32768,   153,    47,
  304.    132,-32768,-32768,   -11,-32768,   175,   182,-32768,-32768,-32768,
  305.     56,    56,    56,-32768,-32768,-32768,    17,-32768,-32768,   -12,
  306.    177,   149,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
  307. -32768,-32768,-32768,-32768,-32768,-32768,   179,-32768,-32768,-32768,
  308.      8,    88,   222,   222,   222,-32768,   173,   190,-32768,-32768,
  309. -32768,-32768,-32768,-32768,   189,   164,-32768,-32768,-32768,   206,
  310.    210,-32768
  311. };
  312.  
  313. static const short yypgoto[] = {-32768,
  314. -32768,   -18,   184,-32768,-32768,-32768,-32768,   -87,    29,-32768,
  315.     78,-32768,    84,-32768,    -5,-32768,  -133,-32768,   -28,-32768,
  316.      2,    16
  317. };
  318.  
  319.  
  320. #define    YYLAST        427
  321.  
  322.  
  323. static const short yytable[] = {    39,
  324.     40,    32,   126,   159,   160,   161,   162,   163,    84,    86,
  325.     70,   120,    90,   118,   121,    33,   147,    66,    67,   168,
  326.    199,    80,   187,    42,    34,   186,    37,    23,   169,   188,
  327.     80,    80,    73,    74,   169,    38,    80,   122,    55,   155,
  328.     80,    41,   148,    80,   106,   107,   200,    43,   110,    80,
  329.     57,    58,   105,    72,    94,    96,   119,    56,    53,   161,
  330.    162,   163,   127,    54,   174,    60,   180,   133,   134,   135,
  331.     59,    61,   111,    95,    97,   113,   114,   109,   175,   176,
  332.    177,   123,   124,    62,   137,   138,   139,   140,   141,   146,
  333.     33,    33,   201,   134,   112,    10,   154,    63,    11,    12,
  334.     13,    14,    64,    15,    16,    17,    18,   128,   129,    65,
  335.     77,    78,    21,    22,   149,   167,   151,    85,   113,   114,
  336.     91,    33,    33,    73,    74,   132,    87,   156,   157,   115,
  337.    116,   117,   109,    88,    75,    76,    89,    92,   104,    93,
  338.     98,   171,   172,    99,   100,    33,    33,   101,   102,   191,
  339.    103,     1,   152,     2,   193,   194,   195,   125,     3,   198,
  340.      4,     5,     6,   153,   158,     7,   173,     8,     9,    10,
  341.    164,   179,    11,    12,    13,    14,   192,    15,    16,    17,
  342.     18,   181,   197,    19,    20,   182,    21,    22,   190,    23,
  343.    189,    24,     2,   205,   206,   207,   196,     3,   203,     4,
  344.      5,     6,   208,   209,     7,   211,    79,     9,    10,   212,
  345.     69,    11,    12,    13,    14,   204,    15,    16,    17,    18,
  346.    202,   165,    80,     0,     2,    21,    22,   166,    23,     3,
  347.     24,     4,     5,     6,     0,     0,     7,     0,    79,     9,
  348.     10,     0,     0,    11,    12,    13,    14,     0,    15,    16,
  349.     17,    18,     0,     0,    80,     0,     2,    21,    22,     0,
  350.     23,     3,    24,     4,     5,     6,     0,     0,     7,     0,
  351.      8,     9,    10,     0,     0,    11,    12,    13,    14,     0,
  352.     15,    16,    17,    18,     0,     0,    80,     0,     2,    21,
  353.     22,     0,    23,     3,    24,     4,     5,     6,     0,     0,
  354.      7,     0,     8,     9,    10,     0,     0,    11,    12,    13,
  355.     14,     0,    15,    16,    17,    18,     0,     0,     0,     0,
  356.      2,    21,    22,     0,    23,     3,    24,     4,     5,     6,
  357.      0,     0,     7,     0,     0,     9,    10,     0,     0,    11,
  358.     12,    13,    14,     0,    15,    16,    17,    18,     0,     0,
  359.     80,     0,     2,    21,    22,     0,    23,     3,    24,     4,
  360.      5,     6,     0,     0,     7,     0,     0,     9,    10,     0,
  361.      0,    11,    12,    13,    14,     0,    15,    16,    17,    18,
  362.      0,     0,     0,     0,     0,    21,    22,     0,    23,     0,
  363.     24,    68,    10,     0,     0,    11,    12,    13,    14,     0,
  364.     15,    16,    17,    18,     0,     0,     0,     0,     0,    21,
  365.     22,    44,    45,    46,    47,     0,    48,     0,    49,    50,
  366.      0,     0,     0,     0,     0,    51,    52
  367. };
  368.  
  369. static const short yycheck[] = {     5,
  370.      6,     0,    90,   137,   138,   139,   140,   141,    37,    38,
  371.     29,    13,    41,    16,    16,     0,    13,    23,    24,     9,
  372.     13,    33,    35,     8,    33,     9,    18,    39,    18,    42,
  373.     33,    33,    20,    21,    18,    18,    33,    39,    19,   127,
  374.     33,    18,    39,    33,    73,    74,    39,    41,    77,    33,
  375.     18,    19,    71,    33,    19,    19,    85,    38,    18,   193,
  376.    194,   195,    91,    18,    18,    18,   154,     5,     6,     7,
  377.     38,    18,    78,    38,    38,    20,    21,    76,    32,    33,
  378.     34,    87,    88,    18,   113,   114,   115,   116,   117,   118,
  379.     75,    76,     5,     6,    79,    19,   125,    18,    22,    23,
  380.     24,    25,    18,    27,    28,    29,    30,   106,   107,    18,
  381.     35,     4,    36,    37,   120,   144,   122,    32,    20,    21,
  382.     42,   106,   107,    20,    21,   110,    13,   133,   134,    31,
  383.     32,    33,   131,    13,    31,    32,    41,    18,    42,    18,
  384.     18,   147,   148,    18,    18,   130,   131,    18,    18,   178,
  385.     40,     1,    14,     3,   183,   184,   185,    42,     8,   188,
  386.     10,    11,    12,    14,     7,    15,    14,    17,    18,    19,
  387.      9,    40,    22,    23,    24,    25,   182,    27,    28,    29,
  388.     30,     7,   188,    33,    34,     4,    36,    37,    40,    39,
  389.     14,    41,     3,   199,   200,   201,    18,     8,    26,    10,
  390.     11,    12,    14,    40,    15,     0,    17,    18,    19,     0,
  391.     27,    22,    23,    24,    25,    26,    27,    28,    29,    30,
  392.    192,   144,    33,    -1,     3,    36,    37,   144,    39,     8,
  393.     41,    10,    11,    12,    -1,    -1,    15,    -1,    17,    18,
  394.     19,    -1,    -1,    22,    23,    24,    25,    -1,    27,    28,
  395.     29,    30,    -1,    -1,    33,    -1,     3,    36,    37,    -1,
  396.     39,     8,    41,    10,    11,    12,    -1,    -1,    15,    -1,
  397.     17,    18,    19,    -1,    -1,    22,    23,    24,    25,    -1,
  398.     27,    28,    29,    30,    -1,    -1,    33,    -1,     3,    36,
  399.     37,    -1,    39,     8,    41,    10,    11,    12,    -1,    -1,
  400.     15,    -1,    17,    18,    19,    -1,    -1,    22,    23,    24,
  401.     25,    -1,    27,    28,    29,    30,    -1,    -1,    -1,    -1,
  402.      3,    36,    37,    -1,    39,     8,    41,    10,    11,    12,
  403.     -1,    -1,    15,    -1,    -1,    18,    19,    -1,    -1,    22,
  404.     23,    24,    25,    -1,    27,    28,    29,    30,    -1,    -1,
  405.     33,    -1,     3,    36,    37,    -1,    39,     8,    41,    10,
  406.     11,    12,    -1,    -1,    15,    -1,    -1,    18,    19,    -1,
  407.     -1,    22,    23,    24,    25,    -1,    27,    28,    29,    30,
  408.     -1,    -1,    -1,    -1,    -1,    36,    37,    -1,    39,    -1,
  409.     41,    18,    19,    -1,    -1,    22,    23,    24,    25,    -1,
  410.     27,    28,    29,    30,    -1,    -1,    -1,    -1,    -1,    36,
  411.     37,    22,    23,    24,    25,    -1,    27,    -1,    29,    30,
  412.     -1,    -1,    -1,    -1,    -1,    36,    37
  413. };
  414. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  415. #line 3 "/net/acae127/home/bammi/lib/bison.simple"
  416.  
  417. /* Skeleton output parser for bison,
  418.    Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
  419.  
  420.    This program is free software; you can redistribute it and/or modify
  421.    it under the terms of the GNU General Public License as published by
  422.    the Free Software Foundation; either version 1, or (at your option)
  423.    any later version.
  424.  
  425.    This program is distributed in the hope that it will be useful,
  426.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  427.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  428.    GNU General Public License for more details.
  429.  
  430.    You should have received a copy of the GNU General Public License
  431.    along with this program; if not, write to the Free Software
  432.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  433.  
  434.  
  435. #ifndef alloca
  436. #ifdef __GNUC__
  437. #define alloca __builtin_alloca
  438. #else /* Not GNU C.  */
  439. #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
  440. #include <alloca.h>
  441. #else /* Not sparc */
  442. #ifdef MSDOS
  443. #include <malloc.h>
  444. #endif /* MSDOS */
  445. #endif /* Not sparc.  */
  446. #endif /* Not GNU C.  */
  447. #endif /* alloca not defined.  */
  448.  
  449. /* This is the parser code that is written into each bison parser
  450.   when the %semantic_parser declaration is not specified in the grammar.
  451.   It was written by Richard Stallman by simplifying the hairy parser
  452.   used when %semantic_parser is specified.  */
  453.  
  454. /* Note: there must be only one dollar sign in this file.
  455.    It is replaced by the list of actions, each action
  456.    as one case of the switch.  */
  457.  
  458. #define yyerrok        (yyerrstatus = 0)
  459. #define yyclearin    (yychar = YYEMPTY)
  460. #define YYEMPTY        -2
  461. #define YYEOF        0
  462. #define YYACCEPT    return(0)
  463. #define YYABORT     return(1)
  464. #define YYERROR        goto yyerrlab1
  465. /* Like YYERROR except do call yyerror.
  466.    This remains here temporarily to ease the
  467.    transition to the new meaning of YYERROR, for GCC.
  468.    Once GCC version 2 has supplanted version 1, this can go.  */
  469. #define YYFAIL        goto yyerrlab
  470. #define YYRECOVERING()  (!!yyerrstatus)
  471. #define YYBACKUP(token, value) \
  472. do                                \
  473.   if (yychar == YYEMPTY && yylen == 1)                \
  474.     { yychar = (token), yylval = (value);            \
  475.       yychar1 = YYTRANSLATE (yychar);                \
  476.       YYPOPSTACK;                        \
  477.       goto yybackup;                        \
  478.     }                                \
  479.   else                                \
  480.     { yyerror ("syntax error: cannot back up"); YYERROR; }    \
  481. while (0)
  482.  
  483. #define YYTERROR    1
  484. #define YYERRCODE    256
  485.  
  486. #ifndef YYPURE
  487. #define YYLEX        yylex()
  488. #endif
  489.  
  490. #ifdef YYPURE
  491. #ifdef YYLSP_NEEDED
  492. #define YYLEX        yylex(&yylval, &yylloc)
  493. #else
  494. #define YYLEX        yylex(&yylval)
  495. #endif
  496. #endif
  497.  
  498. /* If nonreentrant, generate the variables here */
  499.  
  500. #ifndef YYPURE
  501.  
  502. int    yychar;            /*  the lookahead symbol        */
  503. YYSTYPE    yylval;            /*  the semantic value of the        */
  504.                 /*  lookahead symbol            */
  505.  
  506. #ifdef YYLSP_NEEDED
  507. YYLTYPE yylloc;            /*  location data for the lookahead    */
  508.                 /*  symbol                */
  509. #endif
  510.  
  511. int yynerrs;            /*  number of parse errors so far       */
  512. #endif  /* not YYPURE */
  513.  
  514. #if YYDEBUG != 0
  515. int yydebug;            /*  nonzero means print parse trace    */
  516. /* Since this is uninitialized, it does not stop multiple parsers
  517.    from coexisting.  */
  518. #endif
  519.  
  520. /*  YYINITDEPTH indicates the initial size of the parser's stacks    */
  521.  
  522. #ifndef    YYINITDEPTH
  523. #define YYINITDEPTH 200
  524. #endif
  525.  
  526. /*  YYMAXDEPTH is the maximum size the stacks can grow to
  527.     (effective only if the built-in stack extension method is used).  */
  528.  
  529. #if YYMAXDEPTH == 0
  530. #undef YYMAXDEPTH
  531. #endif
  532.  
  533. #ifndef YYMAXDEPTH
  534. #define YYMAXDEPTH 10000
  535. #endif
  536.  
  537. #ifndef __cplusplus
  538.  
  539. /* This is the most reliable way to avoid incompatibilities
  540.    in available built-in functions on various systems.  */
  541. static void
  542. __yy_bcopy (from, to, count)
  543.      char *from;
  544.      char *to;
  545.      int count;
  546. {
  547.   register char *f = from;
  548.   register char *t = to;
  549.   register int i = count;
  550.  
  551.   while (i-- > 0)
  552.     *t++ = *f++;
  553. }
  554.  
  555. #else /* __cplusplus */
  556.  
  557. /* This is the most reliable way to avoid incompatibilities
  558.    in available built-in functions on various systems.  */
  559. static void
  560. __yy_bcopy (char *from, char *to, int count)
  561. {
  562.   register char *f = from;
  563.   register char *t = to;
  564.   register int i = count;
  565.  
  566.   while (i-- > 0)
  567.     *t++ = *f++;
  568. }
  569.  
  570. #endif
  571.  
  572. #line 160 "/net/acae127/home/bammi/lib/bison.simple"
  573. int
  574. yyparse()
  575. {
  576.   register int yystate;
  577.   register int yyn;
  578.   register short *yyssp;
  579.   register YYSTYPE *yyvsp;
  580.   int yyerrstatus;    /*  number of tokens to shift before error messages enabled */
  581.   int yychar1;        /*  lookahead token as an internal (translated) token number */
  582.  
  583.   short    yyssa[YYINITDEPTH];    /*  the state stack            */
  584.   YYSTYPE yyvsa[YYINITDEPTH];    /*  the semantic value stack        */
  585.  
  586.   short *yyss = yyssa;        /*  refer to the stacks thru separate pointers */
  587.   YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */
  588.  
  589. #ifdef YYLSP_NEEDED
  590.   YYLTYPE *yyls = yylsa;
  591.   YYLTYPE *yylsp;
  592.   YYLTYPE yylsa[YYINITDEPTH];    /*  the location stack            */
  593.  
  594. #define YYPOPSTACK   (yyvsp--, yysp--, yylsp--)
  595. #else
  596. #define YYPOPSTACK   (yyvsp--, yysp--)
  597. #endif
  598.  
  599.   int yystacksize = YYINITDEPTH;
  600.  
  601. #ifdef YYPURE
  602.   int yychar;
  603.   YYSTYPE yylval;
  604.   int yynerrs;
  605. #ifdef YYLSP_NEEDED
  606.   YYLTYPE yylloc;
  607. #endif
  608. #endif
  609.  
  610.   YYSTYPE yyval;        /*  the variable used to return        */
  611.                 /*  semantic values from the action    */
  612.                 /*  routines                */
  613.  
  614.   int yylen;
  615.  
  616. #if YYDEBUG != 0
  617.   if (yydebug)
  618.     fprintf(stderr, "Starting parse\n");
  619. #endif
  620.  
  621.   yystate = 0;
  622.   yyerrstatus = 0;
  623.   yynerrs = 0;
  624.   yychar = YYEMPTY;        /* Cause a token to be read.  */
  625.  
  626.   /* Initialize stack pointers.
  627.      Waste one element of value and location stack
  628.      so that they stay on the same level as the state stack.  */
  629.  
  630.   yyssp = yyss - 1;
  631.   yyvsp = yyvs;
  632. #ifdef YYLSP_NEEDED
  633.   yylsp = yyls;
  634. #endif
  635.  
  636. /* Push a new state, which is found in  yystate  .  */
  637. /* In all cases, when you get here, the value and location stacks
  638.    have just been pushed. so pushing a state here evens the stacks.  */
  639. yynewstate:
  640.  
  641.   *++yyssp = yystate;
  642.  
  643.   if (yyssp >= yyss + yystacksize - 1)
  644.     {
  645.       /* Give user a chance to reallocate the stack */
  646.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  647.       YYSTYPE *yyvs1 = yyvs;
  648.       short *yyss1 = yyss;
  649. #ifdef YYLSP_NEEDED
  650.       YYLTYPE *yyls1 = yyls;
  651. #endif
  652.  
  653.       /* Get the current used size of the three stacks, in elements.  */
  654.       int size = yyssp - yyss + 1;
  655.  
  656. #ifdef yyoverflow
  657.       /* Each stack pointer address is followed by the size of
  658.      the data in use in that stack, in bytes.  */
  659.       yyoverflow("parser stack overflow",
  660.          &yyss1, size * sizeof (*yyssp),
  661.          &yyvs1, size * sizeof (*yyvsp),
  662. #ifdef YYLSP_NEEDED
  663.          &yyls1, size * sizeof (*yylsp),
  664. #endif
  665.          &yystacksize);
  666.  
  667.       yyss = yyss1; yyvs = yyvs1;
  668. #ifdef YYLSP_NEEDED
  669.       yyls = yyls1;
  670. #endif
  671. #else /* no yyoverflow */
  672.       /* Extend the stack our own way.  */
  673.       if (yystacksize >= YYMAXDEPTH)
  674.     {
  675.       yyerror("parser stack overflow");
  676.       return 2;
  677.     }
  678.       yystacksize *= 2;
  679.       if (yystacksize > YYMAXDEPTH)
  680.     yystacksize = YYMAXDEPTH;
  681.       yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
  682.       __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
  683.       yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
  684.       __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
  685. #ifdef YYLSP_NEEDED
  686.       yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
  687.       __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
  688. #endif
  689. #endif /* no yyoverflow */
  690.  
  691.       yyssp = yyss + size - 1;
  692.       yyvsp = yyvs + size - 1;
  693. #ifdef YYLSP_NEEDED
  694.       yylsp = yyls + size - 1;
  695. #endif
  696.  
  697. #if YYDEBUG != 0
  698.       if (yydebug)
  699.     fprintf(stderr, "Stack size increased to %d\n", yystacksize);
  700. #endif
  701.  
  702.       if (yyssp >= yyss + yystacksize - 1)
  703.     YYABORT;
  704.     }
  705.  
  706. #if YYDEBUG != 0
  707.   if (yydebug)
  708.     fprintf(stderr, "Entering state %d\n", yystate);
  709. #endif
  710.  
  711.  yybackup:
  712.  
  713. /* Do appropriate processing given the current state.  */
  714. /* Read a lookahead token if we need one and don't already have one.  */
  715. /* yyresume: */
  716.  
  717.   /* First try to decide what to do without reference to lookahead token.  */
  718.  
  719.   yyn = yypact[yystate];
  720.   if (yyn == YYFLAG)
  721.     goto yydefault;
  722.  
  723.   /* Not known => get a lookahead token if don't already have one.  */
  724.  
  725.   /* yychar is either YYEMPTY or YYEOF
  726.      or a valid token in external form.  */
  727.  
  728.   if (yychar == YYEMPTY)
  729.     {
  730. #if YYDEBUG != 0
  731.       if (yydebug)
  732.     fprintf(stderr, "Reading a token: ");
  733. #endif
  734.       yychar = YYLEX;
  735.     }
  736.  
  737.   /* Convert token to internal form (in yychar1) for indexing tables with */
  738.  
  739.   if (yychar <= 0)        /* This means end of input. */
  740.     {
  741.       yychar1 = 0;
  742.       yychar = YYEOF;        /* Don't call YYLEX any more */
  743.  
  744. #if YYDEBUG != 0
  745.       if (yydebug)
  746.     fprintf(stderr, "Now at end of input.\n");
  747. #endif
  748.     }
  749.   else
  750.     {
  751.       yychar1 = YYTRANSLATE(yychar);
  752.  
  753. #if YYDEBUG != 0
  754.       if (yydebug)
  755.     fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
  756. #endif
  757.     }
  758.  
  759.   yyn += yychar1;
  760.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
  761.     goto yydefault;
  762.  
  763.   yyn = yytable[yyn];
  764.  
  765.   /* yyn is what to do for this token type in this state.
  766.      Negative => reduce, -yyn is rule number.
  767.      Positive => shift, yyn is new state.
  768.        New state is final state => don't bother to shift,
  769.        just return success.
  770.      0, or most negative number => error.  */
  771.  
  772.   if (yyn < 0)
  773.     {
  774.       if (yyn == YYFLAG)
  775.     goto yyerrlab;
  776.       yyn = -yyn;
  777.       goto yyreduce;
  778.     }
  779.   else if (yyn == 0)
  780.     goto yyerrlab;
  781.  
  782.   if (yyn == YYFINAL)
  783.     YYACCEPT;
  784.  
  785.   /* Shift the lookahead token.  */
  786.  
  787. #if YYDEBUG != 0
  788.   if (yydebug)
  789.     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
  790. #endif
  791.  
  792.   /* Discard the token being shifted unless it is eof.  */
  793.   if (yychar != YYEOF)
  794.     yychar = YYEMPTY;
  795.  
  796.   *++yyvsp = yylval;
  797. #ifdef YYLSP_NEEDED
  798.   *++yylsp = yylloc;
  799. #endif
  800.  
  801.   /* count tokens shifted since error; after three, turn off error status.  */
  802.   if (yyerrstatus) yyerrstatus--;
  803.  
  804.   yystate = yyn;
  805.   goto yynewstate;
  806.  
  807. /* Do the default action for the current state.  */
  808. yydefault:
  809.  
  810.   yyn = yydefact[yystate];
  811.   if (yyn == 0)
  812.     goto yyerrlab;
  813.  
  814. /* Do a reduction.  yyn is the number of a rule to reduce with.  */
  815. yyreduce:
  816.   yylen = yyr2[yyn];
  817.   yyval = yyvsp[1-yylen]; /* implement default value of the action */
  818.  
  819. #if YYDEBUG != 0
  820.   if (yydebug)
  821.     {
  822.       int i;
  823.  
  824.       fprintf (stderr, "Reducing via rule %d (line %d), ",
  825.            yyn, yyrline[yyn]);
  826.  
  827.       /* Print the symboles being reduced, and their result.  */
  828.       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
  829.     fprintf (stderr, "%s ", yytname[yyrhs[i]]);
  830.       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
  831.     }
  832. #endif
  833.  
  834.  
  835.   switch (yyn) {
  836.  
  837. case 1:
  838. #line 103 "parse.y"
  839. {
  840.               /* Case of regular command.  Discard the error
  841.                  safety net,and return the command just parsed. */
  842.               global_command = yyvsp[-1].command;
  843.               eof_encountered = 0;
  844.               discard_parser_constructs (0);
  845.               YYACCEPT;
  846.             ;
  847.     break;}
  848. case 2:
  849. #line 112 "parse.y"
  850. {
  851.               /* Case of regular command, but not a very
  852.                  interesting one.  Return a NULL command. */
  853.               global_command = (COMMAND *)NULL;
  854.               YYACCEPT;
  855.             ;
  856.     break;}
  857. case 3:
  858. #line 120 "parse.y"
  859. {
  860.               /* Error during parsing.  Return NULL command. */
  861.               global_command = (COMMAND *)NULL;
  862.               eof_encountered = 0;
  863.               discard_parser_constructs (1);
  864.               if (interactive)
  865.                 {
  866.                   YYACCEPT;
  867.                 }
  868.               else
  869.                 {
  870.                   YYABORT;
  871.                 }
  872.             ;
  873.     break;}
  874. case 4:
  875. #line 135 "parse.y"
  876. {
  877.               /* Case of EOF seen by itself.  Do ignoreeof or 
  878.                  not. */
  879.               global_command = (COMMAND *)NULL;
  880.               handle_eof_input_unit ();
  881.               YYACCEPT;
  882.             ;
  883.     break;}
  884. case 5:
  885. #line 145 "parse.y"
  886. { yyval.word_list = (WORD_LIST *)NULL; ;
  887.     break;}
  888. case 6:
  889. #line 147 "parse.y"
  890. { yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-1].word_list); ;
  891.     break;}
  892. case 7:
  893. #line 151 "parse.y"
  894. { yyval.redirect = make_redirection ( 1, r_output_direction, yyvsp[0].word); ;
  895.     break;}
  896. case 8:
  897. #line 153 "parse.y"
  898. { yyval.redirect = make_redirection ( 0, r_input_direction, yyvsp[0].word); ;
  899.     break;}
  900. case 9:
  901. #line 155 "parse.y"
  902. { yyval.redirect = make_redirection (yyvsp[-2].number, r_output_direction, yyvsp[0].word); ;
  903.     break;}
  904. case 10:
  905. #line 157 "parse.y"
  906. { yyval.redirect = make_redirection (yyvsp[-2].number, r_input_direction, yyvsp[0].word); ;
  907.     break;}
  908. case 11:
  909. #line 159 "parse.y"
  910. { yyval.redirect = make_redirection ( 1, r_appending_to, yyvsp[0].word); ;
  911.     break;}
  912. case 12:
  913. #line 161 "parse.y"
  914. { yyval.redirect = make_redirection (yyvsp[-2].number, r_appending_to, yyvsp[0].word); ;
  915.     break;}
  916. case 13:
  917. #line 163 "parse.y"
  918. {
  919.               yyval.redirect = make_redirection ( 0, r_reading_until, yyvsp[0].word);
  920.               redirection_needing_here_doc = yyval.redirect;
  921.               need_here_doc = 1;
  922.             ;
  923.     break;}
  924. case 14:
  925. #line 169 "parse.y"
  926. {
  927.               yyval.redirect = make_redirection (yyvsp[-2].number, r_reading_until, yyvsp[0].word);
  928.               redirection_needing_here_doc = yyval.redirect;
  929.               need_here_doc = 1;
  930.             ;
  931.     break;}
  932. case 15:
  933. #line 175 "parse.y"
  934. { yyval.redirect = make_redirection ( 0, r_duplicating, yyvsp[0].number); ;
  935.     break;}
  936. case 16:
  937. #line 177 "parse.y"
  938. { yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating, yyvsp[0].number); ;
  939.     break;}
  940. case 17:
  941. #line 179 "parse.y"
  942. { yyval.redirect = make_redirection ( 1, r_duplicating, yyvsp[0].number); ;
  943.     break;}
  944. case 18:
  945. #line 181 "parse.y"
  946. { yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating, yyvsp[0].number); ;
  947.     break;}
  948. case 19:
  949. #line 183 "parse.y"
  950. {
  951.               yyval.redirect = make_redirection ( 0, r_deblank_reading_until, yyvsp[0].word);
  952.               redirection_needing_here_doc = yyval.redirect;
  953.               need_here_doc = 1;
  954.             ;
  955.     break;}
  956. case 20:
  957. #line 189 "parse.y"
  958. {
  959.               yyval.redirect = make_redirection (yyvsp[-2].number, r_deblank_reading_until, yyvsp[0].word);
  960.               redirection_needing_here_doc = yyval.redirect;
  961.               need_here_doc = 1;
  962.             ;
  963.     break;}
  964. case 21:
  965. #line 195 "parse.y"
  966. { yyval.redirect = make_redirection ( 1, r_close_this, 0); ;
  967.     break;}
  968. case 22:
  969. #line 197 "parse.y"
  970. { yyval.redirect = make_redirection (yyvsp[-2].number, r_close_this, 0); ;
  971.     break;}
  972. case 23:
  973. #line 199 "parse.y"
  974. { yyval.redirect = make_redirection ( 0, r_close_this, 0); ;
  975.     break;}
  976. case 24:
  977. #line 201 "parse.y"
  978. { yyval.redirect = make_redirection (yyvsp[-2].number, r_close_this, 0); ;
  979.     break;}
  980. case 25:
  981. #line 203 "parse.y"
  982. { yyval.redirect = make_redirection ( 1, r_err_and_out, yyvsp[0].word); ;
  983.     break;}
  984. case 26:
  985. #line 205 "parse.y"
  986. { yyval.redirect = make_redirection ( 1, r_err_and_out, yyvsp[0].word); ;
  987.     break;}
  988. case 27:
  989. #line 207 "parse.y"
  990. { yyval.redirect = make_redirection ( yyvsp[-2].number, r_input_output, yyvsp[0].word); ;
  991.     break;}
  992. case 28:
  993. #line 209 "parse.y"
  994. {
  995.               REDIRECT *t1, *t2;
  996.               extern WORD_DESC *copy_word ();
  997.  
  998.               t1 = make_redirection ( 0, r_input_direction, yyvsp[0].word);
  999.               t2 = make_redirection ( 1, r_output_direction, copy_word (yyvsp[0].word));
  1000.               t1->next = t2;
  1001.               yyval.redirect = t1;
  1002.             ;
  1003.     break;}
  1004. case 29:
  1005. #line 219 "parse.y"
  1006. { yyval.redirect = make_redirection ( 1, r_output_force, yyvsp[0].word); ;
  1007.     break;}
  1008. case 30:
  1009. #line 221 "parse.y"
  1010. { yyval.redirect = make_redirection ( yyvsp[-2].number, r_output_force, yyvsp[0].word); ;
  1011.     break;}
  1012. case 31:
  1013. #line 225 "parse.y"
  1014. { yyval.element.word = yyvsp[0].word; yyval.element.redirect = 0; ;
  1015.     break;}
  1016. case 32:
  1017. #line 227 "parse.y"
  1018. { yyval.element.redirect = yyvsp[0].redirect; yyval.element.word = 0; ;
  1019.     break;}
  1020. case 33:
  1021. #line 231 "parse.y"
  1022. {
  1023.               yyval.redirect = yyvsp[0].redirect;
  1024.             ;
  1025.     break;}
  1026. case 34:
  1027. #line 235 "parse.y"
  1028. { 
  1029.               register REDIRECT *t = yyvsp[-1].redirect;
  1030.  
  1031.               while (t->next)
  1032.                 t = t->next;
  1033.               t->next = yyvsp[0].redirect; 
  1034.               yyval.redirect = yyvsp[-1].redirect;
  1035.             ;
  1036.     break;}
  1037. case 35:
  1038. #line 246 "parse.y"
  1039. { yyval.command = make_simple_command (yyvsp[0].element, (COMMAND *)NULL); ;
  1040.     break;}
  1041. case 36:
  1042. #line 248 "parse.y"
  1043. { yyval.command = make_simple_command (yyvsp[0].element, yyvsp[-1].command); ;
  1044.     break;}
  1045. case 37:
  1046. #line 252 "parse.y"
  1047. { yyval.command = clean_simple_command (yyvsp[0].command); ;
  1048.     break;}
  1049. case 38:
  1050. #line 255 "parse.y"
  1051. { yyval.command = yyvsp[0].command; ;
  1052.     break;}
  1053. case 39:
  1054. #line 258 "parse.y"
  1055. {
  1056.               yyval.command->redirects = yyvsp[0].redirect;
  1057.               yyval.command = yyvsp[-1].command;
  1058.             ;
  1059.     break;}
  1060. case 40:
  1061. #line 265 "parse.y"
  1062. { yyval.command = make_for_command (yyvsp[-4].word, (WORD_LIST *)add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ;
  1063.     break;}
  1064. case 41:
  1065. #line 267 "parse.y"
  1066. { yyval.command = make_for_command (yyvsp[-4].word, (WORD_LIST *)add_string_to_list ("$@", (WORD_LIST *)NULL), yyvsp[-1].command); ;
  1067.     break;}
  1068. case 42:
  1069. #line 269 "parse.y"
  1070. { yyval.command = make_for_command (yyvsp[-5].word, (WORD_LIST *)add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ;
  1071.     break;}
  1072. case 43:
  1073. #line 271 "parse.y"
  1074. { yyval.command = make_for_command (yyvsp[-5].word, (WORD_LIST *)add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command); ;
  1075.     break;}
  1076. case 44:
  1077. #line 274 "parse.y"
  1078. { yyval.command = make_for_command (yyvsp[-8].word, (WORD_LIST *)reverse_list (yyvsp[-5].word_list), yyvsp[-1].command); ;
  1079.     break;}
  1080. case 45:
  1081. #line 276 "parse.y"
  1082. { yyval.command = make_for_command (yyvsp[-8].word, (WORD_LIST *)reverse_list (yyvsp[-5].word_list), yyvsp[-1].command); ;
  1083.     break;}
  1084. case 46:
  1085. #line 279 "parse.y"
  1086. { yyval.command = make_case_command (yyvsp[-4].word, (PATTERN_LIST *)NULL); ;
  1087.     break;}
  1088. case 47:
  1089. #line 281 "parse.y"
  1090. { yyval.command = make_case_command (yyvsp[-5].word, yyvsp[-2].pattern); ;
  1091.     break;}
  1092. case 48:
  1093. #line 283 "parse.y"
  1094. { /* Nobody likes this...
  1095.                  report_syntax_error ("Inserted `;;'"); */
  1096.               yyval.command = make_case_command (yyvsp[-4].word, yyvsp[-1].pattern); ;
  1097.     break;}
  1098. case 49:
  1099. #line 288 "parse.y"
  1100. { yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, (COMMAND *)NULL); ;
  1101.     break;}
  1102. case 50:
  1103. #line 290 "parse.y"
  1104. { yyval.command = make_if_command (yyvsp[-5].command, yyvsp[-3].command, yyvsp[-1].command); ;
  1105.     break;}
  1106. case 51:
  1107. #line 292 "parse.y"
  1108. { yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[-1].command); ;
  1109.     break;}
  1110. case 52:
  1111. #line 295 "parse.y"
  1112. { yyval.command = make_while_command (yyvsp[-3].command, yyvsp[-1].command); ;
  1113.     break;}
  1114. case 53:
  1115. #line 297 "parse.y"
  1116. { yyval.command = make_until_command (yyvsp[-3].command, yyvsp[-1].command); ;
  1117.     break;}
  1118. case 54:
  1119. #line 300 "parse.y"
  1120. { yyvsp[-1].command->subshell = WANT_SUBSHELL; yyval.command = yyvsp[-1].command; ;
  1121.     break;}
  1122. case 55:
  1123. #line 303 "parse.y"
  1124. { yyval.command = yyvsp[0].command; ;
  1125.     break;}
  1126. case 56:
  1127. #line 306 "parse.y"
  1128. { yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command); ;
  1129.     break;}
  1130. case 57:
  1131. #line 309 "parse.y"
  1132. { yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command); ;
  1133.     break;}
  1134. case 58:
  1135. #line 312 "parse.y"
  1136. { yyval.command = make_function_def (yyvsp[-2].word, yyvsp[0].command); ;
  1137.     break;}
  1138. case 59:
  1139. #line 316 "parse.y"
  1140. { yyval.command = make_group_command (yyvsp[-1].command); ;
  1141.     break;}
  1142. case 60:
  1143. #line 320 "parse.y"
  1144. { yyval.command = make_if_command (yyvsp[-2].command, yyvsp[0].command, (COMMAND *)NULL); ;
  1145.     break;}
  1146. case 61:
  1147. #line 322 "parse.y"
  1148. { yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[0].command); ;
  1149.     break;}
  1150. case 62:
  1151. #line 324 "parse.y"
  1152. { yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, yyvsp[0].command); ;
  1153.     break;}
  1154. case 64:
  1155. #line 330 "parse.y"
  1156. { yyvsp[0].pattern->next = yyvsp[-1].pattern; yyval.pattern = yyvsp[0].pattern; ;
  1157.     break;}
  1158. case 65:
  1159. #line 334 "parse.y"
  1160. { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, yyvsp[0].command); ;
  1161.     break;}
  1162. case 66:
  1163. #line 336 "parse.y"
  1164. { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, (COMMAND *)NULL); ;
  1165.     break;}
  1166. case 68:
  1167. #line 342 "parse.y"
  1168. { yyvsp[0].pattern->next = yyvsp[-1].pattern; yyval.pattern = yyvsp[0].pattern; ;
  1169.     break;}
  1170. case 69:
  1171. #line 346 "parse.y"
  1172. { yyval.pattern = make_pattern_list (yyvsp[-3].word_list, yyvsp[-1].command); ;
  1173.     break;}
  1174. case 70:
  1175. #line 348 "parse.y"
  1176. { yyval.pattern = make_pattern_list (yyvsp[-3].word_list, (COMMAND *)NULL); ;
  1177.     break;}
  1178. case 71:
  1179. #line 352 "parse.y"
  1180. { yyval.word_list = make_word_list (yyvsp[0].word, (WORD_LIST *)NULL); ;
  1181.     break;}
  1182. case 72:
  1183. #line 354 "parse.y"
  1184. { yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-2].word_list); ;
  1185.     break;}
  1186. case 73:
  1187. #line 363 "parse.y"
  1188. {
  1189.               yyval.command = yyvsp[0].command;
  1190.               if (need_here_doc)
  1191.                 make_here_document (redirection_needing_here_doc);
  1192.               need_here_doc = 0;
  1193.              ;
  1194.     break;}
  1195. case 76:
  1196. #line 374 "parse.y"
  1197. { yyval.command = command_connect (yyvsp[-2].command, 0, '&'); ;
  1198.     break;}
  1199. case 78:
  1200. #line 380 "parse.y"
  1201. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); ;
  1202.     break;}
  1203. case 79:
  1204. #line 382 "parse.y"
  1205. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); ;
  1206.     break;}
  1207. case 80:
  1208. #line 384 "parse.y"
  1209. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, '&'); ;
  1210.     break;}
  1211. case 81:
  1212. #line 386 "parse.y"
  1213. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); ;
  1214.     break;}
  1215. case 82:
  1216. #line 388 "parse.y"
  1217. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); ;
  1218.     break;}
  1219. case 83:
  1220. #line 390 "parse.y"
  1221. { yyval.command = yyvsp[0].command; ;
  1222.     break;}
  1223. case 84:
  1224. #line 392 "parse.y"
  1225. {
  1226.               yyvsp[0].command->invert_pipeline = 1;
  1227.               yyval.command = yyvsp[0].command;
  1228.             ;
  1229.     break;}
  1230. case 90:
  1231. #line 414 "parse.y"
  1232. {
  1233.               yyval.command = yyvsp[0].command;
  1234.               if (need_here_doc)
  1235.                 make_here_document (redirection_needing_here_doc);
  1236.               need_here_doc = 0;
  1237.             ;
  1238.     break;}
  1239. case 91:
  1240. #line 421 "parse.y"
  1241. {
  1242.               yyval.command = command_connect (yyvsp[-1].command, (COMMAND *)NULL, '&');
  1243.               if (need_here_doc)
  1244.                 make_here_document (redirection_needing_here_doc);
  1245.               need_here_doc = 0;
  1246.             ;
  1247.     break;}
  1248. case 92:
  1249. #line 428 "parse.y"
  1250. {
  1251.               yyval.command = yyvsp[-1].command;
  1252.               if (need_here_doc)
  1253.                 make_here_document (redirection_needing_here_doc);
  1254.               need_here_doc = 0;
  1255.             ;
  1256.     break;}
  1257. case 93:
  1258. #line 437 "parse.y"
  1259. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); ;
  1260.     break;}
  1261. case 94:
  1262. #line 439 "parse.y"
  1263. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); ;
  1264.     break;}
  1265. case 95:
  1266. #line 441 "parse.y"
  1267. { yyval.command = command_connect (yyvsp[-2].command, yyvsp[0].command, '&'); ;
  1268.     break;}
  1269. case 96:
  1270. #line 443 "parse.y"
  1271. { yyval.command = command_connect (yyvsp[-2].command, yyvsp[0].command, ';'); ;
  1272.     break;}
  1273. case 97:
  1274. #line 445 "parse.y"
  1275. { yyval.command = yyvsp[0].command; ;
  1276.     break;}
  1277. case 98:
  1278. #line 447 "parse.y"
  1279. {
  1280.               yyvsp[0].command->invert_pipeline = 1;
  1281.               yyval.command = yyvsp[0].command;
  1282.             ;
  1283.     break;}
  1284. case 99:
  1285. #line 455 "parse.y"
  1286. { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, '|'); ;
  1287.     break;}
  1288. case 100:
  1289. #line 457 "parse.y"
  1290. { yyval.command = yyvsp[0].command; ;
  1291.     break;}
  1292. }
  1293.    /* the action file gets copied in in place of this dollarsign */
  1294. #line 423 "/net/acae127/home/bammi/lib/bison.simple"
  1295.  
  1296.   yyvsp -= yylen;
  1297.   yyssp -= yylen;
  1298. #ifdef YYLSP_NEEDED
  1299.   yylsp -= yylen;
  1300. #endif
  1301.  
  1302. #if YYDEBUG != 0
  1303.   if (yydebug)
  1304.     {
  1305.       short *ssp1 = yyss - 1;
  1306.       fprintf (stderr, "state stack now");
  1307.       while (ssp1 != yyssp)
  1308.     fprintf (stderr, " %d", *++ssp1);
  1309.       fprintf (stderr, "\n");
  1310.     }
  1311. #endif
  1312.  
  1313.   *++yyvsp = yyval;
  1314.  
  1315. #ifdef YYLSP_NEEDED
  1316.   yylsp++;
  1317.   if (yylen == 0)
  1318.     {
  1319.       yylsp->first_line = yylloc.first_line;
  1320.       yylsp->first_column = yylloc.first_column;
  1321.       yylsp->last_line = (yylsp-1)->last_line;
  1322.       yylsp->last_column = (yylsp-1)->last_column;
  1323.       yylsp->text = 0;
  1324.     }
  1325.   else
  1326.     {
  1327.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  1328.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  1329.     }
  1330. #endif
  1331.  
  1332.   /* Now "shift" the result of the reduction.
  1333.      Determine what state that goes to,
  1334.      based on the state we popped back to
  1335.      and the rule number reduced by.  */
  1336.  
  1337.   yyn = yyr1[yyn];
  1338.  
  1339.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  1340.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  1341.     yystate = yytable[yystate];
  1342.   else
  1343.     yystate = yydefgoto[yyn - YYNTBASE];
  1344.  
  1345.   goto yynewstate;
  1346.  
  1347. yyerrlab:   /* here on detecting error */
  1348.  
  1349.   if (! yyerrstatus)
  1350.     /* If not already recovering from an error, report this error.  */
  1351.     {
  1352.       ++yynerrs;
  1353.  
  1354. #ifdef YYERROR_VERBOSE
  1355.       yyn = yypact[yystate];
  1356.  
  1357.       if (yyn > YYFLAG && yyn < YYLAST)
  1358.     {
  1359.       int size = 0;
  1360.       char *msg;
  1361.       int x, count;
  1362.  
  1363.       count = 0;
  1364.       for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
  1365.         if (yycheck[x + yyn] == x)
  1366.           size += strlen(yytname[x]) + 15, count++;
  1367.       msg = (char *) xmalloc(size + 15);
  1368.       strcpy(msg, "parse error");
  1369.  
  1370.       if (count < 5)
  1371.         {
  1372.           count = 0;
  1373.           for (x = 0; x < (sizeof(yytname) / sizeof(char *)); x++)
  1374.         if (yycheck[x + yyn] == x)
  1375.           {
  1376.             strcat(msg, count == 0 ? ", expecting `" : " or `");
  1377.             strcat(msg, yytname[x]);
  1378.             strcat(msg, "'");
  1379.             count++;
  1380.           }
  1381.         }
  1382.       yyerror(msg);
  1383.       free(msg);
  1384.     }
  1385.       else
  1386. #endif /* YYERROR_VERBOSE */
  1387.     yyerror("parse error");
  1388.     }
  1389.  
  1390. yyerrlab1:   /* here on error raised explicitly by an action */
  1391.  
  1392.   if (yyerrstatus == 3)
  1393.     {
  1394.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  1395.  
  1396.       /* return failure if at end of input */
  1397.       if (yychar == YYEOF)
  1398.     YYABORT;
  1399.  
  1400. #if YYDEBUG != 0
  1401.       if (yydebug)
  1402.     fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
  1403. #endif
  1404.  
  1405.       yychar = YYEMPTY;
  1406.     }
  1407.  
  1408.   /* Else will try to reuse lookahead token
  1409.      after shifting the error token.  */
  1410.  
  1411.   yyerrstatus = 3;        /* Each real token shifted decrements this */
  1412.  
  1413.   goto yyerrhandle;
  1414.  
  1415. yyerrdefault:  /* current state does not do anything special for the error token. */
  1416.  
  1417. #if 0
  1418.   /* This is wrong; only states that explicitly want error tokens
  1419.      should shift them.  */
  1420.   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  1421.   if (yyn) goto yydefault;
  1422. #endif
  1423.  
  1424. yyerrpop:   /* pop the current state because it cannot handle the error token */
  1425.  
  1426.   if (yyssp == yyss) YYABORT;
  1427.   yyvsp--;
  1428.   yystate = *--yyssp;
  1429. #ifdef YYLSP_NEEDED
  1430.   yylsp--;
  1431. #endif
  1432.  
  1433. #if YYDEBUG != 0
  1434.   if (yydebug)
  1435.     {
  1436.       short *ssp1 = yyss - 1;
  1437.       fprintf (stderr, "Error: state stack now");
  1438.       while (ssp1 != yyssp)
  1439.     fprintf (stderr, " %d", *++ssp1);
  1440.       fprintf (stderr, "\n");
  1441.     }
  1442. #endif
  1443.  
  1444. yyerrhandle:
  1445.  
  1446.   yyn = yypact[yystate];
  1447.   if (yyn == YYFLAG)
  1448.     goto yyerrdefault;
  1449.  
  1450.   yyn += YYTERROR;
  1451.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
  1452.     goto yyerrdefault;
  1453.  
  1454.   yyn = yytable[yyn];
  1455.   if (yyn < 0)
  1456.     {
  1457.       if (yyn == YYFLAG)
  1458.     goto yyerrpop;
  1459.       yyn = -yyn;
  1460.       goto yyreduce;
  1461.     }
  1462.   else if (yyn == 0)
  1463.     goto yyerrpop;
  1464.  
  1465.   if (yyn == YYFINAL)
  1466.     YYACCEPT;
  1467.  
  1468. #if YYDEBUG != 0
  1469.   if (yydebug)
  1470.     fprintf(stderr, "Shifting error token, ");
  1471. #endif
  1472.  
  1473.   *++yyvsp = yylval;
  1474. #ifdef YYLSP_NEEDED
  1475.   *++yylsp = yylloc;
  1476. #endif
  1477.  
  1478.   yystate = yyn;
  1479.   goto yynewstate;
  1480. }
  1481. #line 459 "parse.y"
  1482.  
  1483.  
  1484. /* Initial size to allocate for tokens, and the
  1485.    amount to grow them by. */
  1486. #define TOKEN_DEFAULT_GROW_SIZE 512
  1487.  
  1488. /* The token currently being read. */
  1489. int current_token = 0;
  1490.  
  1491. /* The last read token, or NULL.  read_token () uses this for context
  1492.    checking. */
  1493. int last_read_token = 0;
  1494.  
  1495. /* The token read prior to last_read_token. */
  1496. int token_before_that = 0;
  1497.  
  1498. /* Global var is non-zero when end of file has been reached. */
  1499. int EOF_Reached = 0;
  1500.  
  1501. /* yy_getc () returns the next available character from input or EOF.
  1502.    yy_ungetc (c) makes `c' the next character to read.
  1503.    init_yy_io (get, unget), makes the function `get' the installed function
  1504.    for getting the next character, and makes `unget' the installed function
  1505.    for un-getting a character. */
  1506. return_EOF ()            /* does nothing good. */
  1507. {
  1508.   return (EOF);
  1509. }
  1510.  
  1511. /* Variables containing the current get and unget functions. */
  1512.  
  1513. /* Some stream `types'. */
  1514. #define st_stream 0
  1515. #define st_string 1
  1516.  
  1517. Function *get_yy_char = return_EOF;
  1518. Function *unget_yy_char = return_EOF;
  1519. int yy_input_type = st_stream;
  1520. FILE *yy_input_dev = (FILE *)NULL;
  1521.  
  1522. /* The current stream name.  In the case of a file, this is a filename. */
  1523. char *stream_name = (char *)NULL;
  1524.  
  1525. /* Function to set get_yy_char and unget_yy_char. */
  1526. init_yy_io (get_function, unget_function, type, location)
  1527.      Function *get_function, *unget_function;
  1528.      int type;
  1529.      FILE *location;
  1530. {
  1531.   get_yy_char = get_function;
  1532.   unget_yy_char = unget_function;
  1533.   yy_input_type = type;
  1534.   yy_input_dev = location;
  1535. }
  1536.  
  1537. /* Call this to get the next character of input. */
  1538. yy_getc ()
  1539. {
  1540.   return (*get_yy_char) ();
  1541. }
  1542.  
  1543. /* Call this to unget C.  That is, to make C the next character
  1544.    to be read. */
  1545. yy_ungetc (c)
  1546. {
  1547.   return (*unget_yy_char) (c);
  1548. }
  1549.  
  1550. /* **************************************************************** */
  1551. /*                                    */
  1552. /*          Let input be read from readline ().            */
  1553. /*                                    */
  1554. /* **************************************************************** */
  1555.  
  1556. #if defined (READLINE)
  1557. char *current_readline_prompt = (char *)NULL;
  1558. char *current_readline_line = (char *)NULL;
  1559. int current_readline_line_index = 0;
  1560.  
  1561. static int readline_initialized_yet = 0;
  1562. int
  1563. yy_readline_get ()
  1564. {
  1565.   if (!current_readline_line)
  1566.     {
  1567.       char *readline ();
  1568.       SigHandler *old_sigint;
  1569.       extern sighandler sigint_sighandler ();
  1570.       extern int interrupt_immediately;
  1571.  
  1572. #if defined (JOB_CONTROL)
  1573.       extern int shell_pgrp, job_control;
  1574. #endif
  1575.  
  1576.       if (!readline_initialized_yet)
  1577.     {
  1578.       initialize_readline ();
  1579.       readline_initialized_yet = 1;
  1580.     }
  1581.  
  1582. #if defined (JOB_CONTROL)
  1583.       if (job_control)
  1584.     give_terminal_to (shell_pgrp);
  1585. #endif /* JOB_CONTROL */
  1586.  
  1587.       old_sigint = (SigHandler *)signal (SIGINT, sigint_sighandler);
  1588.       interrupt_immediately++;
  1589.  
  1590.       if (!current_readline_prompt)
  1591.     current_readline_line = readline ("");
  1592.       else
  1593.     current_readline_line = readline (current_readline_prompt);
  1594.  
  1595.       interrupt_immediately--;
  1596.       signal (SIGINT, old_sigint);
  1597.  
  1598.       /* Reset the prompt to whatever is in the decoded value of
  1599.      prompt_string_pointer. */
  1600.       reset_readline_prompt ();
  1601.  
  1602.       current_readline_line_index = 0;
  1603.  
  1604.       if (!current_readline_line)
  1605.     {
  1606.       current_readline_line_index = 0;
  1607.       return (EOF);
  1608.     }
  1609.  
  1610.       current_readline_line =
  1611.     (char *)xrealloc (current_readline_line,
  1612.               2 + strlen (current_readline_line));
  1613.       strcat (current_readline_line, "\n");
  1614.     }
  1615.  
  1616.   if (!current_readline_line[current_readline_line_index])
  1617.     {
  1618.       free (current_readline_line);
  1619.       current_readline_line = (char *)NULL;
  1620.       return (yy_readline_get ());
  1621.     }
  1622.   else
  1623.     {
  1624.       int c = current_readline_line[current_readline_line_index++];
  1625.       return (c);
  1626.     }
  1627. }
  1628.  
  1629. int
  1630. yy_readline_unget (c)
  1631. {
  1632.   if (current_readline_line_index && current_readline_line)
  1633.     current_readline_line[--current_readline_line_index] = c;
  1634.   return (c);
  1635. }
  1636.   
  1637. with_input_from_stdin ()
  1638. {
  1639.   init_yy_io (yy_readline_get, yy_readline_unget,
  1640.           st_string, (FILE *)current_readline_line);
  1641.   stream_name = savestring ("readline stdin");
  1642. }
  1643.  
  1644. #else  /* !READLINE */
  1645.  
  1646. with_input_from_stdin ()
  1647. {
  1648.   with_input_from_stream (stdin, "stdin");
  1649. }
  1650. #endif    /* !READLINE */
  1651.  
  1652. /* **************************************************************** */
  1653. /*                                    */
  1654. /*   Let input come from STRING.  STRING is zero terminated.        */
  1655. /*                                    */
  1656. /* **************************************************************** */
  1657.  
  1658. int
  1659. yy_string_get ()
  1660. {
  1661.   /* If the string doesn't exist, or is empty, EOF found. */
  1662.   if (!(char *)yy_input_dev || !*(char *)yy_input_dev)
  1663.     return (EOF);
  1664.   else
  1665.     {
  1666.       register char *temp = (char *)yy_input_dev;
  1667.       int c = *temp++;
  1668.       yy_input_dev = (FILE *)temp;
  1669.       return (c);
  1670.     }
  1671. }
  1672.  
  1673. int
  1674. yy_string_unget (c)
  1675.      int c;
  1676. {
  1677.   register char *temp = (char *)yy_input_dev;
  1678.   *(--temp) = c;
  1679.   yy_input_dev = (FILE *)temp;
  1680.   return (c);
  1681. }
  1682.  
  1683. with_input_from_string (string, name)
  1684.      char *string;
  1685.      char *name;
  1686. {
  1687.   init_yy_io (yy_string_get, yy_string_unget, st_string, (FILE *)string);
  1688.   stream_name = savestring (name);
  1689. }
  1690.  
  1691. /* **************************************************************** */
  1692. /*                                    */
  1693. /*             Let input come from STREAM.            */
  1694. /*                                    */
  1695. /* **************************************************************** */
  1696.  
  1697. #if defined(atarist)
  1698. extern int console_read_byte();
  1699. #endif
  1700.  
  1701. int
  1702. yy_stream_get ()
  1703. {
  1704.   if (yy_input_dev)
  1705. #if defined (USG)
  1706.     return (sysv_getc (yy_input_dev));
  1707. #else
  1708. /**
  1709.  ** (sjk)++ Atari ST hack for input
  1710.  **/
  1711. #if !defined(atarist)
  1712.     return (getc (yy_input_dev));
  1713. #else 
  1714.     return(console_read_byte(fileno(yy_input_dev)));
  1715. #endif 
  1716. #endif    /* USG */
  1717.   else return (EOF);
  1718. }
  1719.  
  1720. int
  1721. yy_stream_unget (c)
  1722.      int c;
  1723. {
  1724.   return (ungetc (c, yy_input_dev));
  1725. }
  1726.  
  1727. with_input_from_stream (stream, name)
  1728.      FILE *stream;
  1729.      char *name;
  1730. {
  1731.   init_yy_io (yy_stream_get, yy_stream_unget, st_stream, stream);
  1732.   stream_name = savestring (name);
  1733. }
  1734.  
  1735. typedef struct stream_saver {
  1736.   struct stream_saver *next;
  1737.   Function *getter, *putter;
  1738.   int type, line;
  1739.   char *location, *name;
  1740. } STREAM_SAVER;
  1741.  
  1742. /* The globally known line number. */
  1743. int line_number = 0;
  1744.  
  1745. STREAM_SAVER *stream_list = (STREAM_SAVER *)NULL;
  1746.  
  1747. push_stream ()
  1748. {
  1749.   STREAM_SAVER *temp = (STREAM_SAVER *)xmalloc (sizeof (STREAM_SAVER));
  1750.   temp->type = yy_input_type;
  1751.   temp->location = (char *)yy_input_dev;
  1752.   temp->getter = get_yy_char;
  1753.   temp->putter = unget_yy_char;
  1754.   temp->line = line_number;
  1755.   temp->name = stream_name; stream_name = (char *)NULL;
  1756.   temp->next = stream_list;
  1757.   stream_list = temp;
  1758.   EOF_Reached = line_number = 0;
  1759. }
  1760.  
  1761. pop_stream ()
  1762. {
  1763.   if (!stream_list)
  1764.     {
  1765.       EOF_Reached = 1;
  1766.     }
  1767.   else
  1768.     {
  1769.       STREAM_SAVER *temp = stream_list;
  1770.     
  1771.       EOF_Reached = 0;
  1772.       stream_list = stream_list->next;
  1773.  
  1774.       if (stream_name)
  1775.     free (stream_name);
  1776.       stream_name = temp->name;
  1777.  
  1778.       init_yy_io (temp->getter, temp->putter, temp->type, (FILE *)temp->location);
  1779.       line_number = temp->line;
  1780.       free (temp);
  1781.     }
  1782. }
  1783.  
  1784. /*
  1785.  * This is used to inhibit alias expansion and reserved word recognition
  1786.  * inside case statement pattern lists.     A `case statement pattern list'
  1787.  * is:
  1788.  *    everything between the `in' in a `case word in' and the next ')'
  1789.  *    or `esac'
  1790.  *    everything between a `;;' and the next `)' or `esac'
  1791.  */
  1792. static int in_case_pattern_list = 0;
  1793.  
  1794. #if defined (ALIAS)
  1795. /*
  1796.  * Pseudo-global variables used in implementing token-wise alias expansion.
  1797.  */
  1798.  
  1799. static int expand_next_token = 0;
  1800. static char *current_token_being_expanded = (char *)NULL;
  1801. static char *pending_token_being_expanded = (char *)NULL;
  1802.  
  1803. /*
  1804.  * Pushing and popping strings.     This works together with shell_getc to 
  1805.  * implement alias expansion on a per-token basis.
  1806.  */
  1807.  
  1808. typedef struct string_saver {
  1809.   struct string_saver *next;
  1810.   int expand_alias;  /* value to set expand_alias to when string is popped */
  1811.   char *saved_line;
  1812.   int saved_line_size, saved_line_index, saved_line_terminator;
  1813.   char *saved_token_being_expanded;
  1814. } STRING_SAVER;
  1815.  
  1816. STRING_SAVER *pushed_string_list = (STRING_SAVER *)NULL;
  1817.  
  1818. static void save_expansion ();
  1819.  
  1820. /*
  1821.  * Push the current shell_input_line onto a stack of such lines and make S
  1822.  * the current input.  Used when expanding aliases.  EXPAND is used to set
  1823.  * the value of expand_next_token when the string is popped, so that the
  1824.  * word after the alias in the original line is handled correctly when the
  1825.  * alias expands to multiple words.  TOKEN is the token that was expanded
  1826.  * into S; it is saved and used to prevent infinite recursive expansion.
  1827.  */
  1828. static void
  1829. push_string (s, expand, token)
  1830.      char *s;
  1831.      int expand;
  1832.      char *token;
  1833. {
  1834.   extern char *shell_input_line;
  1835.   extern int shell_input_line_size, shell_input_line_index,
  1836.          shell_input_line_terminator;
  1837.   STRING_SAVER *temp = (STRING_SAVER *) xmalloc (sizeof (STRING_SAVER));
  1838.  
  1839.   temp->expand_alias = expand;
  1840.   temp->saved_line = shell_input_line;
  1841.   temp->saved_line_size = shell_input_line_size;
  1842.   temp->saved_line_index = shell_input_line_index;
  1843.   temp->saved_line_terminator = shell_input_line_terminator;
  1844.   temp->saved_token_being_expanded = current_token_being_expanded;
  1845.   temp->next = pushed_string_list;
  1846.   pushed_string_list = temp;
  1847.  
  1848.   save_expansion (token);
  1849.  
  1850.   current_token_being_expanded = token;
  1851.   shell_input_line = s;
  1852.   shell_input_line_size = strlen (s);
  1853.   shell_input_line_index = 0;
  1854.   shell_input_line_terminator = '\0';
  1855.   expand_next_token = 0;
  1856. }
  1857.  
  1858. /*
  1859.  * Make the top of the pushed_string stack be the current shell input.
  1860.  * Only called when there is something on the stack.  Called from shell_getc
  1861.  * when it thinks it has consumed the string generated by an alias expansion
  1862.  * and needs to return to the original input line.
  1863.  */
  1864. static void
  1865. pop_string ()
  1866. {
  1867.   extern char *shell_input_line;
  1868.   extern int shell_input_line_size, shell_input_line_index,
  1869.          shell_input_line_terminator;
  1870.   STRING_SAVER *t;
  1871.  
  1872.   if (shell_input_line)
  1873.     free (shell_input_line);
  1874.   shell_input_line = pushed_string_list->saved_line;
  1875.   shell_input_line_index = pushed_string_list->saved_line_index;
  1876.   shell_input_line_size = pushed_string_list->saved_line_size;
  1877.   shell_input_line_terminator = pushed_string_list->saved_line_terminator;
  1878.   expand_next_token = pushed_string_list->expand_alias;
  1879.   pending_token_being_expanded = pushed_string_list->saved_token_being_expanded;
  1880.   t = pushed_string_list;
  1881.   pushed_string_list = pushed_string_list->next;
  1882.   free((char *)t);
  1883. }
  1884.  
  1885. static void
  1886. free_string_list ()
  1887. {
  1888.   register STRING_SAVER *t = pushed_string_list, *t1;
  1889.  
  1890.   while (t)
  1891.     {
  1892.       t1 = t->next;
  1893.       if (t->saved_line)
  1894.     free (t->saved_line);
  1895.       if (t->saved_token_being_expanded)
  1896.     free (t->saved_token_being_expanded);
  1897.       free ((char *)t);
  1898.       t = t1;
  1899.     }
  1900.   pushed_string_list = (STRING_SAVER *)NULL;
  1901. }
  1902.  
  1903. /* This is a stack to save the values of all tokens for which alias
  1904.    expansion has been performed during the current call to read_token ().
  1905.    It is used to prevent alias expansion loops:
  1906.  
  1907.       alias foo=bar
  1908.       alias bar=baz
  1909.       alias baz=foo
  1910.  
  1911.    Ideally this would be taken care of by push and pop string, but because
  1912.    of when strings are popped the stack will not contain the correct
  1913.    strings to test against.  (The popping is done in shell_getc, so that when
  1914.    the current string is exhausted, shell_getc can simply pop that string off
  1915.    the stack, restore the previous string, and continue with the character
  1916.    following the token whose expansion was originally pushed on the stack.)
  1917.  
  1918.    What we really want is a record of all tokens that have been expanded for
  1919.    aliases during the `current' call to read_token().  This does that, at the
  1920.    cost of being somewhat special-purpose (OK, OK vile and unclean).  Brian,
  1921.    you had better rewrite this whole piece of garbage before the next version
  1922.    is released.
  1923. */
  1924.  
  1925. typedef struct _exp_saver {
  1926.       struct _exp_saver *next;
  1927.       char *saved_token;
  1928. } EXPANSION_SAVER;
  1929.  
  1930. EXPANSION_SAVER *expanded_token_stack = (EXPANSION_SAVER *)NULL;
  1931.  
  1932. static void
  1933. save_expansion (s)
  1934.      char *s;
  1935. {
  1936.   EXPANSION_SAVER *t;
  1937.  
  1938.   t = (EXPANSION_SAVER *) xmalloc (sizeof (EXPANSION_SAVER));
  1939.   t->saved_token = savestring (s);
  1940.   t->next = expanded_token_stack;
  1941.   expanded_token_stack = t;
  1942. }
  1943.  
  1944. /*
  1945.  * Return 1 if TOKEN has already been expanded in the current `stack' of
  1946.  * expansions.    If it has been expanded already, it will appear as the value
  1947.  * of saved_token for some entry in the stack of expansions created for the
  1948.  * current token being expanded.
  1949.  */
  1950. static int
  1951. token_has_been_expanded (token)
  1952.      char *token;
  1953. {
  1954.   register EXPANSION_SAVER *t = expanded_token_stack;
  1955.  
  1956.   while (t)
  1957.     {
  1958.       if (STREQ (token, t->saved_token))
  1959.     return (1);
  1960.       t = t->next;
  1961.     }
  1962.   return (0);
  1963. }
  1964.  
  1965. static void
  1966. free_expansion_stack ()
  1967. {
  1968.   register EXPANSION_SAVER *t = expanded_token_stack, *t1;
  1969.  
  1970.   while (t)
  1971.     {
  1972.       t1 = t->next;
  1973.       free (t->saved_token);
  1974.       free (t);
  1975.       t = t1;
  1976.     }
  1977.   expanded_token_stack = (EXPANSION_SAVER *)NULL;
  1978. }
  1979.  
  1980. #endif /* ALIAS */
  1981.  
  1982. /* Return a line of text, taken from wherever yylex () reads input.
  1983.    If there is no more input, then we return NULL. */
  1984. char *
  1985. read_a_line ()
  1986. {
  1987.   char *line_buffer = (char *)NULL;
  1988.   int indx = 0, buffer_size = 0;
  1989.   int c;
  1990.  
  1991.   while (1)
  1992.     {
  1993.       c = yy_getc ();
  1994.  
  1995.       if (c == 0)
  1996.     continue;
  1997.  
  1998.       /* If there is no more input, then we return NULL. */
  1999.       if (c == EOF)
  2000.     {
  2001.       c = '\n';
  2002.       if (!line_buffer)
  2003.         return ((char *)NULL);
  2004.     }
  2005.  
  2006.       /* `+2' in case the final (200'th) character in the buffer is a newline;
  2007.      otherwise the code below that NULL-terminates it will write over the
  2008.      201st slot and kill the range checking in free(). */
  2009.       if (indx + 2 > buffer_size)
  2010.     if (!buffer_size)
  2011.       line_buffer = (char *)xmalloc (buffer_size = 200);
  2012.     else
  2013.       line_buffer = (char *)xrealloc (line_buffer, buffer_size += 200);
  2014.  
  2015.       line_buffer[indx++] = c;
  2016.       if (c == '\n')
  2017.     {
  2018.       line_buffer[indx] = '\0';
  2019.       return (line_buffer);
  2020.     }
  2021.     }
  2022. }
  2023.  
  2024. /* Return a line as in read_a_line (), but insure that the prompt is
  2025.    the secondary prompt. */
  2026. char *
  2027. read_secondary_line ()
  2028. {
  2029.   prompt_string_pointer = &ps2_prompt;
  2030.   prompt_again ();
  2031.   return (read_a_line ());
  2032. }
  2033.  
  2034.  
  2035. /* **************************************************************** */
  2036. /*                                    */
  2037. /*                YYLEX ()                */
  2038. /*                                    */
  2039. /* **************************************************************** */
  2040.  
  2041. /* Reserved words.  These are only recognized as the first word of a
  2042.    command.  TOKEN_WORD_ALIST. */
  2043. struct {
  2044.   char *word;
  2045.   int token;
  2046. } token_word_alist[] = {
  2047.   {"if", IF},
  2048.   {"then", THEN},
  2049.   {"else", ELSE},
  2050.   {"elif", ELIF},
  2051.   {"fi", FI},
  2052.   {"case", CASE},
  2053.   {"esac", ESAC},
  2054.   {"for", FOR},
  2055.   {"while", WHILE},
  2056.   {"until", UNTIL},
  2057.   {"do", DO},
  2058.   {"done", DONE},
  2059.   {"in", IN},
  2060.   {"function", FUNCTION},
  2061.   {"{", '{'},
  2062.   {"}", '}'},
  2063.   {"!", BANG},
  2064.   {(char *)NULL, 0}
  2065. };
  2066.  
  2067. /* Where shell input comes from.  History expansion is performed on each
  2068.    line, when the shell is interactive. */
  2069. char *shell_input_line = (char *)NULL;
  2070. int shell_input_line_index = 0;
  2071. int shell_input_line_size = 0;    /* amount allocated for shell_input_line */
  2072. int shell_input_line_len = 0;    /* strlen (shell_input_line) */
  2073.  
  2074. /* Either zero, or EOF. */
  2075. int shell_input_line_terminator = 0;
  2076.  
  2077. /* Return the next shell input character.  This always reads characters
  2078.    from shell_input_line; when that line is exhausted, it is time to
  2079.    read the next line. */
  2080. int
  2081. shell_getc (remove_quoted_newline)
  2082.      int remove_quoted_newline;
  2083. {
  2084.   extern int login_shell;
  2085.   int c;
  2086.  
  2087.   QUIT;    /* XXX this is experimental */
  2088.  
  2089. #if defined (ALIAS)
  2090.   /* If shell_input_line[shell_input_line_index] == 0, but there is
  2091.      something on the pushed list of strings, then we don't want to go
  2092.      off and get another line.    We let the code down below handle it. */
  2093.  
  2094.   if (!shell_input_line || ((!shell_input_line[shell_input_line_index]) &&
  2095.                 (pushed_string_list == (STRING_SAVER *)NULL)))
  2096. #else /* !ALIAS */
  2097.   if (!shell_input_line || !shell_input_line[shell_input_line_index])
  2098. #endif /* !ALIAS */
  2099.     {
  2100.       register int i, l;
  2101.       char *pre_process_line (), *expansions;
  2102.  
  2103.       restart_read_next_line:
  2104.  
  2105.       line_number++;
  2106.  
  2107.     restart_read:
  2108.  
  2109.       QUIT;    /* XXX experimental */
  2110.  
  2111.       i = 0;
  2112.       shell_input_line_terminator = 0;
  2113.  
  2114. #if defined (JOB_CONTROL)
  2115.       notify_and_cleanup ();
  2116. #endif
  2117.  
  2118.       clearerr (stdin);
  2119.       while (c = yy_getc ())
  2120.     {
  2121.       if (i + 2 > shell_input_line_size)
  2122.         shell_input_line = (char *)
  2123.           xrealloc (shell_input_line, shell_input_line_size += 256);
  2124.  
  2125.       if (c == EOF)
  2126.         {
  2127.           clearerr (stdin);
  2128.  
  2129.           if (!i)
  2130.         shell_input_line_terminator = EOF;
  2131.  
  2132.           shell_input_line[i] = '\0';
  2133.           break;
  2134.         }
  2135.  
  2136.       shell_input_line[i++] = c;
  2137.  
  2138.       if (c == '\n')
  2139.         {
  2140.           shell_input_line[--i] = '\0';
  2141.           break;
  2142.         }
  2143.     }
  2144.       shell_input_line_index = 0;
  2145.       shell_input_line_len = i;        /* == strlen (shell_input_line) */
  2146.  
  2147.       if (!shell_input_line[0])
  2148.     goto after_pre_process;
  2149.  
  2150.       if (interactive)
  2151.     {
  2152.       expansions = pre_process_line (shell_input_line, 1, 1);
  2153.  
  2154.       free (shell_input_line);
  2155.       shell_input_line = expansions;
  2156.       shell_input_line_len = shell_input_line ?
  2157.                  strlen (shell_input_line) :
  2158.                  0;
  2159.       /* We have to force the xrealloc below because we don't know the
  2160.          true allocated size of shell_input_line anymore. */
  2161.       shell_input_line_size = shell_input_line_len;
  2162.     }
  2163.  
  2164.   after_pre_process:
  2165.       if (shell_input_line)
  2166.     {
  2167.       if (echo_input_at_read)
  2168.         fprintf (stderr, "%s\n", shell_input_line);
  2169.     }
  2170.       else
  2171.     {
  2172.       shell_input_line_size = 0;
  2173.       prompt_string_pointer = ¤t_prompt_string;
  2174.       prompt_again ();
  2175.       goto restart_read;
  2176.     }
  2177.  
  2178.       /* Add the newline to the end of this string, iff the string does
  2179.      not already end in an EOF character.  */
  2180.       if (shell_input_line_terminator != EOF)
  2181.     {
  2182.       l = shell_input_line_len;    /* was a call to strlen */
  2183.  
  2184.       if (l + 3 > shell_input_line_size)
  2185.         shell_input_line = (char *)xrealloc (shell_input_line,
  2186.                     1 + (shell_input_line_size += 2));
  2187.  
  2188.       strcpy (shell_input_line + l, "\n");
  2189.     }
  2190.     }
  2191.   
  2192.   c = shell_input_line[shell_input_line_index];
  2193.  
  2194.   if (c)
  2195.     shell_input_line_index++;
  2196.  
  2197.   if (c == '\\' && remove_quoted_newline &&
  2198.       shell_input_line[shell_input_line_index] == '\n')
  2199.     {
  2200.     prompt_again ();
  2201.     goto restart_read_next_line;
  2202.     }
  2203.  
  2204. #if defined (ALIAS)
  2205.   /*
  2206.    * If c is NULL, we have reached the end of the current input string.     If
  2207.    * pushed_string_list is non-empty, it's time to pop to the previous string
  2208.    * because we have fully consumed the result of the last alias expansion.
  2209.    * Do it transparently; just return the next character of the string popped
  2210.    * to.  We need to hang onto current_token_being_expanded until the token
  2211.    * currently being read has been recognized; we can't restore it in
  2212.    * pop_string () because the token currently being read would be
  2213.    * inappropriately compared with it.    We defer restoration until the next
  2214.    * call to read_token ().
  2215.    */
  2216.  
  2217.   if (!c && (pushed_string_list != (STRING_SAVER *)NULL))
  2218.     {
  2219.       pop_string ();
  2220.       c = shell_input_line[shell_input_line_index];
  2221.       if (c)
  2222.     shell_input_line_index++;
  2223.     }
  2224. #endif /* ALIAS */
  2225.  
  2226.   if (!c && shell_input_line_terminator == EOF)
  2227.     {
  2228.       if (shell_input_line_index != 0)
  2229.     return ('\n');
  2230.       else
  2231.     return (EOF);
  2232.     }
  2233.  
  2234.   return (c);
  2235. }
  2236.  
  2237. /* Put C back into the input for the shell. */
  2238. shell_ungetc (c)
  2239.      int c;
  2240. {
  2241.   if (shell_input_line && shell_input_line_index)
  2242.     shell_input_line[--shell_input_line_index] = c;
  2243. }
  2244.  
  2245. /* Discard input until CHARACTER is seen. */
  2246. discard_until (character)
  2247.      int character;
  2248. {
  2249.   int c;
  2250.   while ((c = shell_getc (0)) != EOF && c != character)
  2251.     ;
  2252.   if (c != EOF )
  2253.     shell_ungetc (c);
  2254. }
  2255.  
  2256. #if defined (HISTORY_REDITING)
  2257. /* Tell readline () that we have some text for it to edit. */
  2258. re_edit (text)
  2259.      char *text;
  2260. {
  2261. #if defined (READLINE)
  2262.   if (strcmp (stream_name, "readline stdin") == 0)
  2263.     bash_re_edit (text);
  2264. #endif /* READLINE */
  2265. }
  2266. #endif /* HISTORY_REDITING */
  2267.  
  2268. /* Non-zero means do no history expansion on this line, regardless
  2269.    of what history_expansion says. */
  2270. int history_expansion_inhibited = 0;
  2271.  
  2272. /* Do pre-processing on LINE.  If PRINT_CHANGES is non-zero, then
  2273.    print the results of expanding the line if there were any changes.
  2274.    If there is an error, return NULL, otherwise the expanded line is
  2275.    returned.  If ADDIT is non-zero the line is added to the history
  2276.    list after history expansion.  ADDIT is just a suggestion;
  2277.    REMEMBER_ON_HISTORY can veto, and does.
  2278.    Right now this does history expansion. */
  2279. char *
  2280. pre_process_line (line, print_changes, addit)
  2281.      char *line;
  2282.      int print_changes, addit;
  2283. {
  2284.   char *return_value = line;
  2285.   int expanded = 0;
  2286.  
  2287.   extern int history_expansion;
  2288.   extern int remember_on_history;
  2289.   int history_expand ();
  2290.   char *history_value;
  2291.  
  2292.   /* History expand the line.  If this results in no errors, then
  2293.      add that line to the history if ADDIT is non-zero. */
  2294.   if (!history_expansion_inhibited && history_expansion)
  2295.     {
  2296.       expanded = history_expand (line, &history_value);
  2297.  
  2298.       if (expanded)
  2299.     {
  2300.       if (print_changes)
  2301.         fprintf (stderr, "%s\n", history_value);
  2302.  
  2303.       /* If there was an error, return NULL. */
  2304.       if (expanded < 0)
  2305.         {
  2306.           free (history_value);
  2307.  
  2308. #if defined (HISTORY_REDITING)
  2309.           /* New hack.  We can allow the user to edit the
  2310.          failed history expansion. */
  2311.           re_edit (line);
  2312. #endif /* HISTORY_REDITING */
  2313.           return ((char *)NULL);
  2314.         }
  2315.     }
  2316.  
  2317.       /* Let other expansions know that return_value can be free'ed,
  2318.      and that a line has been added to the history list.  Note
  2319.      that we only add lines that have something in them. */
  2320.       expanded = 1;
  2321.       return_value = history_value;
  2322.     }
  2323.  
  2324.   if (addit && remember_on_history && *return_value)
  2325.     {
  2326.       extern int history_control;
  2327.       extern int history_lines_this_session;
  2328.  
  2329.       switch (history_control)
  2330.     {
  2331.       case 0:
  2332.         add_history (return_value);
  2333.         history_lines_this_session++;
  2334.         break;
  2335.       case 1:
  2336.         if (*return_value != ' ')
  2337.           {
  2338.         add_history (return_value);
  2339.         history_lines_this_session++;
  2340.           }
  2341.         break;
  2342.       case 2:
  2343.         {
  2344.           HIST_ENTRY *temp;
  2345.  
  2346.           using_history ();
  2347.           temp = previous_history ();
  2348.           if (!temp || (strcmp (temp->line, return_value) != 0))
  2349.         {
  2350.           add_history (return_value);
  2351.           history_lines_this_session++;
  2352.         }
  2353.           using_history ();
  2354.         }
  2355.         break;
  2356.     }
  2357.     }
  2358.  
  2359.   if (!expanded)
  2360.     return_value = savestring (line);
  2361.  
  2362.   return (return_value);
  2363. }
  2364.  
  2365.  
  2366. /* Place to remember the token.     We try to keep the buffer
  2367.    at a reasonable size, but it can grow. */
  2368. char *token = (char *)NULL;
  2369.  
  2370. /* Current size of the token buffer. */
  2371. int token_buffer_size = 0;
  2372.  
  2373. /* Command to read_token () explaining what we want it to do. */
  2374. #define READ 0
  2375. #define RESET 1
  2376. #define prompt_is_ps1 \
  2377.       (!prompt_string_pointer || prompt_string_pointer == &ps1_prompt)
  2378.  
  2379. /* Function for yyparse to call.  yylex keeps track of
  2380.    the last two tokens read, and calls read_token.  */
  2381.  
  2382. yylex ()
  2383. {
  2384.   if (interactive && (!current_token || current_token == '\n'))
  2385.     {
  2386.  
  2387. /**
  2388.  ** (sjk)++
  2389.  **/
  2390. #if !defined(atarist)
  2391.       /* Before we print a prompt, we might have to check mailboxes.
  2392.      We do this only if it is time to do so. Notice that only here
  2393.      is the mail alarm reset; nothing takes place in check_mail ()
  2394.      except the checking of mail.  Please don't change this. */
  2395.       if (prompt_is_ps1 && time_to_check_mail ())
  2396.     {
  2397.       check_mail ();
  2398.       reset_mail_timer ();
  2399.     }
  2400. #endif
  2401.  
  2402.       /* Allow the execution of a random command just before the printing
  2403.      of each primary prompt.  If the shell variable PROMPT_COMMAND
  2404.      is set then the value of it is the command to execute. */
  2405.       if (prompt_is_ps1)
  2406.     {
  2407.       char *command_to_execute = get_string_value ("PROMPT_COMMAND");
  2408.  
  2409.       if (command_to_execute)
  2410.         {
  2411.           extern Function *last_shell_builtin, *this_shell_builtin;
  2412.           extern int last_command_exit_value;
  2413.           Function *temp_last, *temp_this;
  2414.           int temp_exit_value, temp_eof_encountered;
  2415.  
  2416.           temp_last = last_shell_builtin;
  2417.           temp_this = this_shell_builtin;
  2418.           temp_exit_value = last_command_exit_value;
  2419.           temp_eof_encountered = eof_encountered;
  2420.  
  2421.           parse_and_execute
  2422.         (savestring (command_to_execute), "PROMPT_COMMAND");
  2423.  
  2424.           last_shell_builtin = temp_last;
  2425.           this_shell_builtin = temp_this;
  2426.           last_command_exit_value = temp_exit_value;
  2427.           eof_encountered = temp_eof_encountered;
  2428.         }
  2429.     }
  2430.       prompt_again ();
  2431.     }
  2432.  
  2433.   token_before_that = last_read_token;
  2434.   last_read_token = current_token;
  2435.   current_token = read_token (READ);
  2436.   return (current_token);
  2437. }
  2438.  
  2439. /* Called from shell.c when Control-C is typed at top level.  Or
  2440.    by the error rule at top level. */
  2441. reset_parser ()
  2442. {
  2443.   read_token (RESET);
  2444. }
  2445.   
  2446. /* When non-zero, we have read the required tokens
  2447.    which allow ESAC to be the next one read. */
  2448. static int allow_esac_as_next = 0;
  2449.  
  2450. /* When non-zero, accept single '{' as a token itself. */
  2451. static int allow_open_brace = 0;
  2452.  
  2453. /* DELIMITER is the value of the delimiter that is currently
  2454.    enclosing, or zero for none. */
  2455. static int delimiter = 0;
  2456. static int old_delimiter = 0;
  2457.  
  2458. /* When non-zero, an open-brace used to create a group is awaiting a close
  2459.    brace partner. */
  2460. static int open_brace_awaiting_satisfaction = 0;
  2461.  
  2462. /* If non-zero, it is the token that we want read_token to return regardless
  2463.    of what text is (or isn't) present to be read.  read_token resets this. */
  2464. int token_to_read = 0;
  2465.  
  2466. /* Read the next token.     Command can be READ (normal operation) or 
  2467.    RESET (to normalize state). */
  2468. read_token (command)
  2469.      int command;
  2470. {
  2471.   extern int interactive_shell;    /* Whether the current shell is interactive. */
  2472.   int character;        /* Current character. */
  2473.   int peek_char;        /* Temporary look-ahead character. */
  2474.   int result;            /* The thing to return. */
  2475.   WORD_DESC *the_word;        /* The value for YYLVAL when a WORD is read. */
  2476.  
  2477.   if (token_buffer_size < TOKEN_DEFAULT_GROW_SIZE)
  2478.     {
  2479.       if (token)
  2480.     free (token);
  2481.       token = (char *)xmalloc (token_buffer_size = TOKEN_DEFAULT_GROW_SIZE);
  2482.     }
  2483.  
  2484.   if (command == RESET)
  2485.     {
  2486.       delimiter = old_delimiter = 0;
  2487.       open_brace_awaiting_satisfaction = 0;
  2488.       in_case_pattern_list = 0;
  2489.  
  2490. #if defined (ALIAS)
  2491.       if (pushed_string_list)
  2492.     {
  2493.       free_string_list ();
  2494.       pushed_string_list = (STRING_SAVER *)NULL;
  2495.     }
  2496.       if (pending_token_being_expanded)
  2497.     {
  2498.       free (pending_token_being_expanded);
  2499.       pending_token_being_expanded = (char *)NULL;
  2500.     }
  2501.       if (current_token_being_expanded)
  2502.     {
  2503.       free (current_token_being_expanded);
  2504.       current_token_being_expanded = (char *)NULL;
  2505.     }
  2506.  
  2507.       if (expanded_token_stack)
  2508.     {
  2509.       free_expansion_stack ();
  2510.       expanded_token_stack = (EXPANSION_SAVER *)NULL;
  2511.     }
  2512. #endif /* ALIAS */
  2513.  
  2514.       if (shell_input_line)
  2515.     {
  2516.       free (shell_input_line);
  2517.       shell_input_line = (char *)NULL;
  2518.       shell_input_line_size = shell_input_line_index = 0;
  2519.     }
  2520.       last_read_token = '\n';
  2521.       token_to_read = '\n';
  2522.       return;
  2523.     }
  2524.  
  2525.   if (token_to_read)
  2526.     {
  2527.       int rt = token_to_read;
  2528.       token_to_read = 0;
  2529.       return (rt);
  2530.     }
  2531.  
  2532. #if defined (ALIAS)
  2533.   /*
  2534.    * Now we can replace current_token_being_expanded with 
  2535.    * pending_token_being_expanded, since the token that would be 
  2536.    * inappropriately compared has already been returned.
  2537.    *
  2538.    * To see why restoring current_token_being_expanded in pop_string ()
  2539.    * could be a problem, consider "alias foo=foo".  Then try to
  2540.    * expand `foo'.  The initial value of current_token_being_expanded is
  2541.    * NULL, so that is what is pushed onto pushed_string_list as the
  2542.    * value of saved_token_being_expanded.  "foo" then becomes shell_input_line.
  2543.    * read_token calls shell_getc for `f', `o', `o', and then shell_getc
  2544.    * hits the end of shell_input_line.    pushed_string_list is not empty
  2545.    * so it gets popped.     If we were to blindly restore
  2546.    * current_token_being_expanded at this point, `foo' would be compared
  2547.    * with a NULL string in the check for recursive expansion, and would
  2548.    * infinitely recurse.
  2549.    */
  2550.   if (pending_token_being_expanded)
  2551.     {
  2552.       if (current_token_being_expanded)
  2553.     free (current_token_being_expanded);
  2554.       current_token_being_expanded = pending_token_being_expanded;
  2555.       pending_token_being_expanded = (char *)NULL;
  2556.     }
  2557.  
  2558.   /* If we hit read_token () and there are no saved strings on the
  2559.      pushed_string_list, then we are no longer currently expanding a
  2560.      token.  This can't be done in pop_stream, because pop_stream
  2561.      may pop the stream before the current token has finished being
  2562.      completely expanded (consider what happens when we alias foo to foo,
  2563.      and then try to expand it). */
  2564.   if (!pushed_string_list && current_token_being_expanded)
  2565.     {
  2566.       free (current_token_being_expanded);
  2567.       current_token_being_expanded = (char *)NULL;
  2568.  
  2569.       if (expanded_token_stack)
  2570.     {
  2571.       free_expansion_stack ();
  2572.       expanded_token_stack = (EXPANSION_SAVER *)NULL;
  2573.     }
  2574.     }
  2575.  
  2576.   /* This is a place to jump back to once we have successfully expanded a
  2577.      token with an alias and pushed the string with push_string () */
  2578. re_read_token:
  2579.  
  2580. #endif /* ALIAS */
  2581.  
  2582.   /* Read a single word from input.  Start by skipping blanks. */
  2583.   while ((character = shell_getc (1)) != EOF && whitespace (character));
  2584.  
  2585.   if (character == EOF)
  2586.     return (yacc_EOF);
  2587.  
  2588.   if (character == '#' && !interactive)
  2589.     {
  2590.       /* A comment.  Discard until EOL or EOF, and then return a newline. */
  2591.       discard_until ('\n');
  2592.       shell_getc (0);
  2593.  
  2594.       /* If we're about to return an unquoted newline, we can go and collect
  2595.      the text of any pending here document. */
  2596.       if (need_here_doc)
  2597.     make_here_document (redirection_needing_here_doc);
  2598.       need_here_doc = 0;
  2599.  
  2600.       return ('\n');
  2601.     }
  2602.  
  2603.   if (character == '\n')
  2604.     {
  2605.       /* If we're about to return an unquoted newline, we can go and collect
  2606.      the text of any pending here document. */
  2607.       if (need_here_doc)
  2608.     make_here_document (redirection_needing_here_doc);
  2609.       need_here_doc = 0;
  2610.  
  2611.       return (character);
  2612.     }
  2613.  
  2614.   if (member (character, "()<>;&|"))
  2615.     {
  2616.       /* Please note that the shell does not allow whitespace to
  2617.      appear in between tokens which are character pairs, such as
  2618.      "<<" or ">>".    I believe this is the correct behaviour. */
  2619.  
  2620.       if (character == (peek_char = shell_getc (1)))
  2621.     {
  2622.       switch (character)
  2623.         {
  2624.           /* If '<' then we could be at "<<" or at "<<-".  We have to
  2625.          look ahead one more character. */
  2626.         case '<':
  2627.           peek_char = shell_getc (1);
  2628.           if (peek_char == '-')
  2629.         return (LESS_LESS_MINUS);
  2630.           else
  2631.         {
  2632.           shell_ungetc (peek_char);
  2633.           return (LESS_LESS);
  2634.         }
  2635.  
  2636.         case '>': return (GREATER_GREATER);
  2637.         case ';':
  2638.               in_case_pattern_list = 1;
  2639.               return (SEMI_SEMI);
  2640.         case '&': return (AND_AND);
  2641.         case '|': return (OR_OR);
  2642.         }
  2643.     }
  2644.       else
  2645.     {
  2646.       if (peek_char == '&')
  2647.         {
  2648.           switch (character)
  2649.         {
  2650.         case '<': return (LESS_AND);
  2651.         case '>': return (GREATER_AND);
  2652.         }
  2653.         }
  2654.       if (character == '<' && peek_char == '>')
  2655.         return (LESS_GREATER);
  2656.       if (character == '>' && peek_char == '|')
  2657.         return (GREATER_BAR);
  2658.       if (peek_char == '>' && character == '&')
  2659.         return (AND_GREATER);
  2660.     }
  2661.       shell_ungetc (peek_char);
  2662.  
  2663.       /* If we look like we are reading the start of a function
  2664.      definition, then let the reader know about it so that
  2665.      we will do the right thing with `{'. */
  2666.       if (character == ')' &&
  2667.       last_read_token == '(' && token_before_that == WORD)
  2668.     allow_open_brace = 1;
  2669.  
  2670.       if (in_case_pattern_list && (character == ')'))
  2671.     in_case_pattern_list = 0;
  2672.  
  2673.       return (character);
  2674.     }
  2675.  
  2676.   /* Hack <&- (close stdin) case. */
  2677.   if (character == '-')
  2678.     {
  2679.       switch (last_read_token)
  2680.     {
  2681.     case LESS_AND:
  2682.     case GREATER_AND:
  2683.       return (character);
  2684.     }
  2685.     }
  2686.   
  2687.   /* Okay, if we got this far, we have to read a word.    Read one,
  2688.      and then check it against the known ones. */
  2689.   {
  2690.     /* Index into the token that we are building. */
  2691.     int token_index = 0;
  2692.  
  2693.     /* ALL_DIGITS becomes zero when we see a non-digit. */
  2694.     int all_digits = digit (character);
  2695.  
  2696.     /* DOLLAR_PRESENT becomes non-zero if we see a `$'. */
  2697.     int dollar_present = 0;
  2698.  
  2699.     /* QUOTED becomes non-zero if we see one of ("), ('), (`), or (\). */
  2700.     int quoted = 0;
  2701.  
  2702.     /* Non-zero means to ignore the value of the next character, and just
  2703.        to add it no matter what. */
  2704.     int pass_next_character = 0;
  2705.  
  2706.     /* Non-zero means parsing a dollar-paren construct.     It is the count of
  2707.        un-quoted closes we need to see. */
  2708.     int dollar_paren_level = 0;
  2709.  
  2710.     /* Non-zero means parsing a dollar-bracket construct ($[...]).  It is
  2711.        the count of un-quoted `]' characters we need to see. */
  2712.     int dollar_bracket_level = 0;
  2713.  
  2714.     /* Another level variable.    This one is for dollar_parens inside of
  2715.        double-quotes. */
  2716.     int delimited_paren_level = 0;
  2717.  
  2718.     for (;;)
  2719.       {
  2720.     if (character == EOF)
  2721.       goto got_token;
  2722.  
  2723.     if (pass_next_character)
  2724.       {
  2725.         pass_next_character = 0;
  2726.         goto got_character;
  2727.       }
  2728.  
  2729.       if (delimiter && character == '\\' && delimiter != '\'')
  2730.     {
  2731.       peek_char = shell_getc (0);
  2732.       if (peek_char != '\\')
  2733.         shell_ungetc (peek_char);
  2734.       else
  2735.         {
  2736.           token[token_index++] = character;
  2737.           goto got_character;
  2738.         }
  2739.     }
  2740.  
  2741.     /* Handle backslashes.    Quote lots of things when not inside of
  2742.        double-quotes, quote some things inside of double-quotes. */
  2743.        
  2744.     if (character == '\\' && delimiter != '\'')
  2745.       {
  2746.         peek_char = shell_getc (0);
  2747.  
  2748.         /* Backslash-newline is ignored in all cases excepting
  2749.            when quoted with single quotes. */
  2750.         if (peek_char == '\n')
  2751.           {
  2752.         character = '\n';
  2753.         goto next_character;
  2754.           }
  2755.         else
  2756.           {
  2757.         shell_ungetc (peek_char);
  2758.  
  2759.         /* If the next character is to be quoted, do it now. */
  2760.         if (!delimiter || delimiter == '`' ||
  2761.             ((delimiter == '"' ) &&
  2762.              (member (peek_char, slashify_in_quotes))))
  2763.           {
  2764.             pass_next_character++;
  2765.             quoted = 1;
  2766.             goto got_character;
  2767.           }
  2768.           }
  2769.       }
  2770.  
  2771.     /* This is a hack, in its present form.     If a backquote substitution
  2772.        appears within double quotes, everything within the backquotes
  2773.        should be read as part of a single word.  Jesus.  Now I see why
  2774.        Korn introduced the $() form. */
  2775.     if (delimiter && delimiter == '"' && character == '`')
  2776.       {
  2777.         old_delimiter = delimiter;
  2778.         delimiter = character;
  2779.         goto got_character;
  2780.       }
  2781.  
  2782.     if (delimiter)
  2783.       {
  2784.         if (character == delimiter)
  2785.           {
  2786.         if (delimited_paren_level)
  2787.           {
  2788. #if defined (NOTDEF)
  2789.             report_error ("Expected ')' before %c", character);
  2790.             return ('\n');
  2791. #else
  2792.             goto got_character;
  2793. #endif /* NOTDEF */
  2794.           }
  2795.  
  2796.         delimiter = 0;
  2797.  
  2798.         if (old_delimiter == '"' && character == '`')
  2799.           {
  2800.             delimiter = old_delimiter;
  2801.             old_delimiter = 0;
  2802.           }
  2803.  
  2804.         goto got_character;
  2805.           }
  2806.       }
  2807.  
  2808.     if (!delimiter || delimiter == '`' || delimiter == '"')
  2809.       {
  2810.         if (character == '$')
  2811.           {
  2812.         peek_char = shell_getc (1);
  2813.         shell_ungetc (peek_char);
  2814.         if (peek_char == '(')
  2815.           {
  2816.             if (!delimiter)
  2817.               dollar_paren_level++;
  2818.             else
  2819.               delimited_paren_level++;
  2820.  
  2821.             pass_next_character++;
  2822.             goto got_character;
  2823.           }
  2824.         else if (peek_char == '[')
  2825.           {
  2826.             if (!delimiter)
  2827.               dollar_bracket_level++;
  2828.  
  2829.             pass_next_character++;
  2830.             goto got_character;
  2831.           }
  2832.           }
  2833.  
  2834.         /* If we are parsing a $() or $[] construct, we need to balance
  2835.            parens and brackets inside the construct.  This whole function
  2836.            could use a rewrite. */
  2837.         if (character == '(')
  2838.           {
  2839.         if (delimiter && delimited_paren_level)
  2840.           delimited_paren_level++;
  2841.  
  2842.         if (!delimiter && dollar_paren_level)
  2843.           dollar_paren_level++;
  2844.           }
  2845.  
  2846.         if (character == '[')
  2847.           {
  2848.         if (!delimiter && dollar_bracket_level)
  2849.           dollar_bracket_level++;
  2850.           }
  2851.  
  2852.         /* This code needs to take into account whether we are inside a
  2853.            case statement pattern list, and whether this paren is supposed
  2854.            to terminate it (hey, it could happen).  It's not as simple
  2855.            as just using in_case_pattern_list, because we're not parsing
  2856.            anything while we're reading a $( ) construct.  Maybe we
  2857.            should move that whole mess into the yacc parser. */
  2858.         if (character == ')')
  2859.           {
  2860.         if (delimiter && delimited_paren_level)
  2861.           delimited_paren_level--;
  2862.  
  2863.         if (!delimiter && dollar_paren_level)
  2864.           {
  2865.             dollar_paren_level--;
  2866.             goto got_character;
  2867.           }
  2868.           }
  2869.  
  2870.         if (character == ']')
  2871.           {
  2872.         if (!delimiter && dollar_bracket_level)
  2873.           {
  2874.             dollar_bracket_level--;
  2875.             goto got_character;
  2876.           }
  2877.           }
  2878.       }
  2879.  
  2880.     if (!dollar_paren_level && !dollar_bracket_level && !delimiter &&
  2881.         member (character, " \t\n;&()|<>"))
  2882.       {
  2883.         shell_ungetc (character);
  2884.         goto got_token;
  2885.       }
  2886.     
  2887.     if (!delimiter)
  2888.       {
  2889.         if (character == '"' || character == '`' || character == '\'')
  2890.           {
  2891.         quoted = 1;
  2892.         delimiter = character;
  2893.         goto got_character;
  2894.           }
  2895.       }
  2896.  
  2897.     if (all_digits) all_digits = digit (character);
  2898.     if (character == '$') dollar_present = 1;
  2899.  
  2900.       got_character:
  2901.  
  2902.     token[token_index++] = character;
  2903.  
  2904.     if (token_index == (token_buffer_size - 1))
  2905.       token = (char *)xrealloc (token, (token_buffer_size
  2906.                         += TOKEN_DEFAULT_GROW_SIZE));
  2907.     {
  2908.       char *decode_prompt_string ();
  2909.  
  2910.     next_character:
  2911.       if (character == '\n' && interactive && yy_input_type != st_string)
  2912.         prompt_again ();
  2913.     }
  2914.     /* We want to remove quoted newlines (that is, a \<newline> pair)
  2915.        unless we are within single quotes or pass_next_character is
  2916.        set (the shell equivalent of literal-next). */
  2917.     character = shell_getc ((delimiter != '\'') && (!pass_next_character));
  2918.       }
  2919.  
  2920.   got_token:
  2921.  
  2922.     token[token_index] = '\0';
  2923.     
  2924.     if ((delimiter || dollar_paren_level || dollar_bracket_level) && character == EOF)
  2925.       {
  2926.     if (dollar_paren_level && !delimiter)
  2927.       delimiter = ')';
  2928.     else if (dollar_bracket_level && !delimiter)
  2929.       delimiter = ']';
  2930.  
  2931.     report_error ("Unexpected EOF.    Looking for `%c'.", delimiter);
  2932.     return (-1);
  2933.       }
  2934.  
  2935.     if (all_digits)
  2936.       {
  2937.     /* Check to see what thing we should return.  If the last_read_token
  2938.        is a `<', or a `&', or the character which ended this token is
  2939.        a '>' or '<', then, and ONLY then, is this input token a NUMBER.
  2940.        Otherwise, it is just a word, and should be returned as such. */
  2941.  
  2942.     if ((character == '<' || character == '>') ||
  2943.         (last_read_token == LESS_AND ||
  2944.          last_read_token == GREATER_AND))
  2945.       {
  2946.         yylval.number = atoi (token); /* was sscanf (token, "%d", &(yylval.number)); */
  2947.         return (NUMBER);
  2948.       }
  2949.       }
  2950.  
  2951.     /* Handle special case.  IN is recognized if the last token
  2952.        was WORD and the token before that was FOR or CASE. */
  2953.     if ((last_read_token == WORD) &&
  2954.     ((token_before_that == FOR) || (token_before_that == CASE)) &&
  2955.     (STREQ (token, "in")))
  2956.       {
  2957.     if (token_before_that == CASE)
  2958.       {
  2959.         in_case_pattern_list = 1;
  2960.         allow_esac_as_next++;
  2961.       }
  2962.     return (IN);
  2963.       }
  2964.  
  2965.     /* Ditto for DO in the FOR case. */
  2966.     if ((last_read_token == WORD) && (token_before_that == FOR) &&
  2967.     (STREQ (token, "do")))
  2968.       return (DO);
  2969.  
  2970.     /* Ditto for ESAC in the CASE case. 
  2971.        Specifically, this handles "case word in esac", which is a legal
  2972.        construct, certainly because someone will pass an empty arg to the
  2973.        case construct, and we don't want it to barf.  Of course, we should
  2974.        insist that the case construct has at least one pattern in it, but
  2975.        the designers disagree. */
  2976.     if (allow_esac_as_next)
  2977.       {
  2978.     allow_esac_as_next--;
  2979.     if (STREQ (token, "esac"))
  2980.       {
  2981.         in_case_pattern_list = 0;
  2982.         return (ESAC);
  2983.       }
  2984.       }
  2985.  
  2986.     /* Ditto for `{' in the FUNCTION case. */
  2987.     if (allow_open_brace)
  2988.       {
  2989.     allow_open_brace = 0;
  2990.     if (STREQ (token, "{"))
  2991.       {
  2992.         open_brace_awaiting_satisfaction++;
  2993.         return ('{');
  2994.       }
  2995.       }
  2996.  
  2997. #ifdef ALIAS
  2998.     /* OK, we have a token.  Let's try to alias expand it, if (and only if)
  2999.        it's eligible. 
  3000.  
  3001.        Criteria:
  3002.         No dollar sign
  3003.         Unquoted
  3004.         Not all digits
  3005.         An identifier (all alphanumeric or underscore, first character
  3006.         is not a digit)
  3007.         Last token read was a command separator or expand_next_alias
  3008.         is set
  3009.         We are currently processing an alias (pushed_string_list is
  3010.         non-empty) and this token is not the same as the alias we're
  3011.         currently processing (or any alias we have previously
  3012.         processed.
  3013.  
  3014.        Special cases that disqualify:
  3015.         In a pattern list in a case statement (in_case_pattern_list)
  3016.     */
  3017.     if (interactive_shell && !dollar_present && !quoted &&
  3018.     !all_digits && !in_case_pattern_list &&
  3019.     (command_token_position (last_read_token) || expand_next_token))
  3020.       {
  3021.     char *alias_expand_word (), *expanded;
  3022.     if (current_token_being_expanded &&
  3023.          ((STREQ (token, current_token_being_expanded)) ||
  3024.           (token_has_been_expanded (token))))
  3025.       goto no_expansion;
  3026.  
  3027.     expanded = alias_expand_word (token);
  3028.     if (expanded)
  3029.       {
  3030.         int len = strlen (expanded), expand_next;
  3031.         char *temp;
  3032.  
  3033.         token_index = 0;    /* effectively erase current token */
  3034.  
  3035.         expand_next = (expanded[len - 1] == ' ') ||
  3036.               (expanded[len - 1] == '\t');
  3037.  
  3038.         temp = savestring (token);
  3039.         push_string (expanded, expand_next, temp);
  3040.         goto re_read_token;
  3041.       }
  3042.     else
  3043.       /* This is an eligible token that does not have an expansion. */
  3044. no_expansion:
  3045.       expand_next_token = 0;
  3046.       }
  3047.     else
  3048.       {
  3049.     expand_next_token = 0;
  3050.       }
  3051. #endif /* ALIAS */
  3052.  
  3053.     /* Check to see if it is a reserved word.  */
  3054.     if (!dollar_present && !quoted &&
  3055.     reserved_word_acceptable (last_read_token))
  3056.       {
  3057.     int i;
  3058.     for (i = 0; token_word_alist[i].word != (char *)NULL; i++)
  3059.       if (STREQ (token, token_word_alist[i].word))
  3060.         {
  3061.           if (token_word_alist[i].token == '{')
  3062.         open_brace_awaiting_satisfaction++;
  3063.  
  3064.           if (in_case_pattern_list && (token_word_alist[i].token != ESAC))
  3065.         break;
  3066.  
  3067.           if (token_word_alist[i].token == ESAC)
  3068.         in_case_pattern_list = 0;
  3069.  
  3070.           return (token_word_alist[i].token);
  3071.         }
  3072.       }
  3073.  
  3074.     /* What if we are attempting to satisfy an open-brace grouper? */
  3075.     if (open_brace_awaiting_satisfaction && strcmp (token, "}") == 0)
  3076.       {
  3077.     open_brace_awaiting_satisfaction--;
  3078.     return ('}');
  3079.       }
  3080.  
  3081.     the_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC));
  3082.     the_word->word = (char *)xmalloc (1 + strlen (token));
  3083.     strcpy (the_word->word, token);
  3084.     the_word->dollar_present = dollar_present;
  3085.     the_word->quoted = quoted;
  3086.     the_word->assignment = assignment (token);
  3087.  
  3088.     yylval.word = the_word;
  3089.     result = WORD;
  3090.     if (last_read_token == FUNCTION)
  3091.       allow_open_brace = 1;
  3092.   }
  3093.   return (result);
  3094. }
  3095.  
  3096. #if defined (NOTDEF)        /* Obsoleted function no longer used. */
  3097. /* Return 1 if this token is a legal shell `identifier'; that is, it consists
  3098.    solely of letters, digits, and underscores, and does not begin with a 
  3099.    digit. */
  3100. legal_identifier (name)
  3101.      char *name;
  3102. {
  3103.   register char *s;
  3104.  
  3105.   if (!name || !*name)
  3106.     return (0);
  3107.  
  3108.   if (digit (*name))
  3109.     return (0);
  3110.  
  3111.   for (s = name; s && *s; s++)
  3112.     {
  3113.       if (!isletter (*s) && !digit (*s) && (*s != '_'))
  3114.     return (0);
  3115.     }
  3116.   return (1);
  3117. }
  3118. #endif /* NOTDEF */
  3119.  
  3120. #ifdef ALIAS
  3121. /* Return 1 if TOKEN is a command separating token. */
  3122. command_token_position (token)
  3123.      int token;
  3124. {
  3125.   if (member (token, "\n;(|&{") ||
  3126.       token == AND_AND ||
  3127.       token == OR_OR ||
  3128.       token == BANG ||        /* XXX */
  3129.       token == 0)
  3130.     return (1);
  3131.   else
  3132.     return (0);
  3133. }
  3134. #endif /* ALIAS */
  3135.  
  3136. /* Return 1 if TOKEN is a token that after being read would allow
  3137.    a reserved word to be seen, else 0. */
  3138. reserved_word_acceptable (token)
  3139.      int token;
  3140. {
  3141.   if (member (token, "\n;()|&{") ||
  3142.       token == AND_AND ||
  3143.       token == OR_OR ||
  3144.       token == SEMI_SEMI ||
  3145.       token == DO ||
  3146.       token == IF ||
  3147.       token == WHILE ||
  3148.       token == UNTIL ||
  3149.       token == THEN ||
  3150.       token == ELSE ||
  3151.       token == ELIF ||
  3152.       token == BANG ||
  3153.       token == 0)
  3154.     return (1);
  3155.   else
  3156.     return (0);
  3157. }
  3158.  
  3159. #if defined (READLINE)
  3160. /* Called after each time readline is called.  This insures that whatever
  3161.    the new prompt string is gets propagated to readline's local prompt
  3162.    variable. */
  3163. reset_readline_prompt ()
  3164. {
  3165.   if (prompt_string_pointer && *prompt_string_pointer)
  3166.     {
  3167.       char *temp_prompt, *decode_prompt_string ();
  3168.  
  3169.       temp_prompt = decode_prompt_string (*prompt_string_pointer);
  3170.  
  3171.       if (!temp_prompt)
  3172.     temp_prompt = savestring ("");
  3173.  
  3174.       if (current_readline_prompt)
  3175.     free (current_readline_prompt);
  3176.  
  3177.       current_readline_prompt = temp_prompt;
  3178.     }
  3179. }
  3180. #endif
  3181.  
  3182. /* Issue a prompt, or prepare to issue a prompt when the next character
  3183.    is read. */
  3184. prompt_again ()
  3185. {
  3186.   char *temp_prompt, *decode_prompt_string ();
  3187.  
  3188.   ps1_prompt = get_string_value ("PS1");
  3189.   ps2_prompt = get_string_value ("PS2");
  3190.  
  3191.   if (!prompt_string_pointer)
  3192.     prompt_string_pointer = &ps1_prompt;
  3193.  
  3194.   if (*prompt_string_pointer)
  3195.     temp_prompt = decode_prompt_string (*prompt_string_pointer);
  3196.   else
  3197.     temp_prompt = savestring ("");
  3198.  
  3199.   current_prompt_string = *prompt_string_pointer;
  3200.   prompt_string_pointer = &ps2_prompt;
  3201.  
  3202. #if defined (READLINE)
  3203.   if (!no_line_editing)
  3204.     {
  3205.       if (current_readline_prompt)
  3206.     free (current_readline_prompt);
  3207.       
  3208.       current_readline_prompt = temp_prompt;
  3209.     }
  3210.   else
  3211. #endif    /* READLINE */
  3212.     {
  3213.       if (interactive)
  3214.     {
  3215.       fprintf (stderr, "%s", temp_prompt);
  3216.       fflush (stderr);
  3217.     }
  3218.       free (temp_prompt);
  3219.     }
  3220. }
  3221.  
  3222. /* This sucks. but it is just a crock for System V systems.  The whole idea
  3223.    of MAXPATHLEN is a crock if you ask me.  Why can't we just have
  3224.    dynamically defined sizes?  (UCSB crashes every 20 minutes on me.) */
  3225. #ifndef MAXPATHLEN
  3226. #if !defined(atarist)
  3227. #define MAXPATHLEN 1024
  3228. #else 
  3229. #define MAXPATHLEN 128
  3230. #endif
  3231. #endif    /* MAXPATHLEN */
  3232.  
  3233. /* Return a string which will be printed as a prompt.  The string
  3234.    may contain special characters which are decoded as follows:
  3235.    
  3236.     \t    the time
  3237.     \d    the date
  3238.     \n    CRLF
  3239.     \s    the name of the shell
  3240.     \w    the current working directory
  3241.     \W    the last element of PWD
  3242.     \u    your username
  3243.     \h    the hostname
  3244.     \#    the command number of this command
  3245.     \!    the history number of this command
  3246.     \$    a $ or a # if you are root
  3247.     \<octal> character code in octal
  3248.     \\    a backslash
  3249. */
  3250. #include <sys/param.h>
  3251. #include <time.h>
  3252.  
  3253. #define PROMPT_GROWTH 50
  3254. char *
  3255. decode_prompt_string (string)
  3256.      char *string;
  3257. {
  3258.   int result_size = PROMPT_GROWTH;
  3259.   int result_index = 0;
  3260.   char *result = (char *)xmalloc (PROMPT_GROWTH);
  3261.   int c;
  3262.   char *temp = (char *)NULL;
  3263.  
  3264.   result[0] = 0;
  3265.   while (c = *string++)
  3266.     {
  3267.       if (c == '\\')
  3268.     {
  3269.       c = *string;
  3270.  
  3271.       switch (c)
  3272.         {
  3273.  
  3274.         case '0':
  3275.         case '1':
  3276.         case '2':
  3277.         case '3':
  3278.         case '4':
  3279.         case '5':
  3280.         case '6':
  3281.         case '7':
  3282.           {
  3283.         char octal_string[4];
  3284.         int n;
  3285.  
  3286.         strncpy (octal_string, string, 3);
  3287.         octal_string[3] = '\0';
  3288.  
  3289.         n = read_octal (octal_string);
  3290.  
  3291.         temp = savestring ("\\");
  3292.         if (n != -1)
  3293.           {
  3294.             string += 3;
  3295.             temp[0] = n;
  3296.           }
  3297.  
  3298.         c = 0;
  3299.         goto add_string;
  3300.           }
  3301.       
  3302.         case 't':
  3303.         case 'd':
  3304.  
  3305.           /* Make the current time/date into a string. */
  3306.           {
  3307.         long the_time = time (0);
  3308.         char *ttemp = ctime (&the_time);
  3309.         temp = savestring (ttemp);
  3310.  
  3311.         if (c == 't')
  3312.           {
  3313.             strcpy (temp, temp + 11);
  3314.             temp[8] = '\0';
  3315.           }
  3316.         else
  3317.           temp[10] = '\0';
  3318.  
  3319.         goto add_string;
  3320.           }
  3321.  
  3322.         case 'n':
  3323.           temp = savestring ("\r\n");
  3324.           goto add_string;
  3325.  
  3326.         case 's':
  3327.           {
  3328.         extern char *shell_name;
  3329.         temp = savestring (shell_name);
  3330.         goto add_string;
  3331.           }
  3332.     
  3333.         case 'w':
  3334.         case 'W':
  3335.           {
  3336.         /* Use the value of PWD because it is much more effecient. */
  3337. #define EFFICIENT
  3338. #ifdef EFFICIENT
  3339.         char *polite_directory_format (), t_string[MAXPATHLEN];
  3340.  
  3341.         temp = get_string_value ("PWD");
  3342.  
  3343.         if (!temp)
  3344.           getwd (t_string);
  3345.         else
  3346.           strcpy (t_string, temp);
  3347. #else
  3348.         getwd (t_string);
  3349. #endif    /* EFFICIENT */
  3350.  
  3351.         if (c == 'W')
  3352.           {
  3353.             char *dir = (char *)rindex (t_string, '/');
  3354.             if (dir && dir != t_string)
  3355.               strcpy (t_string, dir + 1);
  3356.             temp = savestring (t_string);
  3357.           }
  3358.         else
  3359.           temp = savestring (polite_directory_format (t_string));
  3360.         goto add_string;
  3361.           }
  3362.       
  3363.         case 'u':
  3364.           {
  3365.         extern char *current_user_name;
  3366.         temp = savestring (current_user_name);
  3367.  
  3368.         goto add_string;
  3369.           }
  3370.  
  3371.         case 'h':
  3372.           {
  3373.         extern char *current_host_name;
  3374.         char *t_string;
  3375.  
  3376.         temp = savestring (current_host_name);
  3377.         if (t_string = (char *)index (temp, '.'))
  3378.           *t_string = '\0';
  3379.         
  3380.         goto add_string;
  3381.           }
  3382.  
  3383.         case '#':
  3384.           {
  3385.         extern int current_command_number;
  3386.         char number_buffer[20];
  3387.         sprintf (number_buffer, "%d", current_command_number);
  3388.         temp = savestring (number_buffer);
  3389.         goto add_string;
  3390.           }
  3391.  
  3392.         case '!':
  3393.           {
  3394.         extern int history_base, where_history ();
  3395.         char number_buffer[20];
  3396.  
  3397.         using_history ();
  3398.         if (get_string_value ("HISTSIZE"))
  3399.           sprintf (number_buffer, "%d",
  3400.                history_base + where_history ());
  3401.         else
  3402.           strcpy (number_buffer, "!");
  3403.         temp = savestring (number_buffer);
  3404.         goto add_string;
  3405.           }
  3406.  
  3407.         case '$':
  3408.           temp = savestring (geteuid () == 0 ? "#" : "$");
  3409.           goto add_string;
  3410.  
  3411.         case '\\':
  3412.           temp = savestring ("\\");
  3413.           goto add_string;
  3414.  
  3415.         default:
  3416.           temp = savestring ("\\ ");
  3417.           temp[1] = c;
  3418.  
  3419.         add_string:
  3420.           if (c)
  3421.         string++;
  3422.           result =
  3423.         (char *)sub_append_string (temp, result,
  3424.                        &result_index, &result_size);
  3425.           temp = (char *)NULL; /* Free ()'ed in sub_append_string (). */
  3426.           result[result_index] = '\0';
  3427.           break;
  3428.         }
  3429.     }
  3430.       else
  3431.     {
  3432.       while (3 + result_index > result_size)
  3433.         result = (char *)xrealloc (result, result_size += PROMPT_GROWTH);
  3434.  
  3435.       result[result_index++] = c;
  3436.       result[result_index] = '\0';
  3437.     }
  3438.     }
  3439.  
  3440.   /* I don't really think that this is a good idea.  Do you? */
  3441.   if (!find_variable ("NO_PROMPT_VARS"))
  3442.     {
  3443.       WORD_LIST *expand_string (), *list;
  3444.       char *string_list ();
  3445.  
  3446.       list = expand_string (result, 1);
  3447.       free (result);
  3448.       result = string_list (list);
  3449.       dispose_words (list);
  3450.     }
  3451.  
  3452.   return (result);
  3453. }
  3454.  
  3455. /* Report a syntax error, and restart the parser.  Call here for fatal
  3456.    errors. */
  3457. yyerror ()
  3458. {
  3459.   report_syntax_error ((char *)NULL);
  3460.   reset_parser ();
  3461. }
  3462.  
  3463. /* Report a syntax error with line numbers, etc.
  3464.    Call here for recoverable errors.  If you have a message to print,
  3465.    then place it in MESSAGE, otherwise pass NULL and this will figure
  3466.    out an appropriate message for you. */
  3467. report_syntax_error (message)
  3468.      char *message;
  3469. {
  3470.   if (message)
  3471.     {
  3472.       if (!interactive)
  3473.     {
  3474.       char *name = stream_name ? stream_name : "stdin";
  3475.       report_error ("%s:%d: `%s'", name, line_number, message);
  3476.     }
  3477.       else
  3478.     report_error ("%s", message);
  3479.  
  3480.       return;
  3481.     }
  3482.  
  3483.   if (shell_input_line && *shell_input_line)
  3484.     {
  3485.       char *error_token, *t = shell_input_line;
  3486.       register int i = shell_input_line_index;
  3487.       int token_end = 0;
  3488.  
  3489.       if (!t[i] && i)
  3490.     i--;
  3491.  
  3492.       while (i && (t[i] == ' ' || t[i] == '\t' || t[i] == '\n'))
  3493.     i--;
  3494.  
  3495.       if (i)
  3496.     token_end = i + 1;
  3497.  
  3498.       while (i && !member (t[i], " \n\t;|&"))
  3499.     i--;
  3500.  
  3501.       while (i != token_end && member (t[i], " \n\t"))
  3502.     i++;
  3503.  
  3504.       if (token_end)
  3505.     {
  3506.       error_token = (char *)alloca (1 + (token_end - i));
  3507.       strncpy (error_token, t + i, token_end - i);
  3508.       error_token[token_end - i] = '\0';
  3509.  
  3510.       report_error ("syntax error near `%s'", error_token);
  3511.     }
  3512.       else if ((i == 0) && (token_end == 0))    /* a 1-character token */
  3513.     {
  3514.       error_token = (char *) alloca (2);
  3515.       strncpy(error_token, t + i, 1);
  3516.       error_token[1] = '\0';
  3517.  
  3518.       report_error ("syntax error near `%s'", error_token);
  3519.     }
  3520.  
  3521.       if (!interactive)
  3522.     {
  3523.       char *temp = savestring (shell_input_line);
  3524.       char *name = stream_name ? stream_name : "stdin";
  3525.       int l = strlen (temp);
  3526.  
  3527.       while (l && temp[l - 1] == '\n')
  3528.         temp[--l] = '\0';
  3529.  
  3530.       report_error ("%s:%d: `%s'", name, line_number, temp);
  3531.       free (temp);
  3532.     }
  3533.     }
  3534.   else
  3535.     report_error ("Syntax error");
  3536. }
  3537.  
  3538. /* ??? Needed function. ??? We have to be able to discard the constructs
  3539.    created during parsing.  In the case of error, we want to return
  3540.    allocated objects to the memory pool.  In the case of no error, we want
  3541.    to throw away the information about where the allocated objects live.
  3542.    (dispose_command () will actually free the command. */
  3543. discard_parser_constructs (error_p)
  3544.      int error_p;
  3545. {
  3546. /*   if (error_p) {
  3547.      fprintf (stderr, "*");
  3548.   } */
  3549. }
  3550.    
  3551. /* Do that silly `type "bye" to exit' stuff.  You know, "ignoreeof". */
  3552.  
  3553. /* The number of times that we have encountered an EOF character without
  3554.    another character intervening.  When this gets above the limit, the
  3555.    shell terminates. */
  3556. int eof_encountered = 0;
  3557.  
  3558. /* The limit for eof_encountered. */
  3559. int eof_encountered_limit = 10;
  3560.  
  3561. /* If we have EOF as the only input unit, this user wants to leave
  3562.    the shell.  If the shell is not interactive, then just leave.
  3563.    Otherwise, if ignoreeof is set, and we haven't done this the
  3564.    required number of times in a row, print a message. */
  3565. handle_eof_input_unit ()
  3566. {
  3567.   extern int login_shell, EOF_Reached;
  3568.  
  3569.   if (interactive)
  3570.     {
  3571.       /* If the user wants to "ignore" eof, then let her do so, kind of. */
  3572.       if (find_variable ("ignoreeof") || find_variable ("IGNOREEOF"))
  3573.     {
  3574.       if (eof_encountered < eof_encountered_limit)
  3575.         {
  3576.           fprintf (stderr, "Use \"%s\" to leave the shell.\n",
  3577.                login_shell ? "logout" : "exit");
  3578.           eof_encountered++;
  3579.           /* Reset the prompt string to be $PS1. */
  3580.           prompt_string_pointer = (char **)NULL;
  3581.           prompt_again ();
  3582.           last_read_token = current_token = '\n';
  3583.           return;
  3584.         } 
  3585.     }
  3586.  
  3587.       /* In this case EOF should exit the shell.  Do it now. */
  3588.       reset_parser ();
  3589.       exit_builtin ((WORD_LIST *)NULL);
  3590.     }
  3591.   else
  3592.     {
  3593.       /* We don't write history files, etc., for non-interactive shells. */
  3594.       EOF_Reached = 1;
  3595.     }
  3596. }
  3597.